Die Daten werden nicht in benachbarten Speicherplätzen wie Arrays gespeichert. Und jedes verknüpfte Element wird als Knoten bezeichnet und durch die Zeiger verbunden. Head ist der Anfangsknoten in der Liste der Links. Dynamisch ist die Größe der zugehörigen Liste. Wir können also eine beliebige Anzahl von Knoten ohne den Gerätespeicher haben. Zwei Arten von Listen sind verbunden. Schauen wir uns die gründliche Lektion nach der anderen an.

Einfach verknüpfte Liste

Eine verknüpfte Liste hat einen einzelnen Zeiger in der verknüpften Liste, der mit dem nächsten Knoten verbunden ist. Für jeden Knoten in der verknüpften Liste müssen wir die Daten und den Zeiger speichern. Null als nächster Indikator für das Ende der verknüpften Liste enthält den letzten Knoten in der verknüpften Liste.

Zunächst wird der Linked-List-Knoten erstellt. Wir können den Knoten mit der Python-Klasse einfach erstellen. Die Klasse enthält Daten und den nächsten Knotenzeiger.

class Node:
	def __init__(self, data):
		self.data = data
		self.next = None

class LinkedList:
	def __init__(self):
		self.head = None

class LinkedList:
	def insert(self, new_node):
		if self.head:
			last_node = self.head
			while last_node != None:
				last_node = last_node.next
			last_node.next = new_node
		else:
			self.head = new_node

class LinkedList:
	def display(self):
		temp_node = self.head
		while temp_node != None:
			print(temp_node.data, end='->')
			temp_node = temp_node.next
		print('Null')

class Node:
	def __init__(self, data):
		self.data = data
		self.next = None
class LinkedList:
	def __init__(self):
		self.head = None
	def insert(self, new_node):
		if self.head:
			last_node = self.head
			while last_node.next != None:
				last_node = last_node.next
			last_node.next = new_node
		else:
			self.head = new_node
	def display(self):
		temp_node = self.head
		while temp_node != None:
			print(temp_node.data, end='->')
			temp_node = temp_node.next
		print('Null')
if __name__ == '__main__':
	linked_list = LinkedList()
	linked_list.insert(Node(1))
	linked_list.insert(Node(2))
	linked_list.insert(Node(3))
	linked_list.insert(Node(4))
	linked_list.insert(Node(5))
	linked_list.insert(Node(6))
	linked_list.insert(Node(7))
	linked_list.display()

1->2->3->4->5->6->7->Null

Doppelt verknüpfte Liste

Eine doppelt verknüpfte Liste hat zwei Indikatoren in der verknüpften Liste, die mit dem vorhergehenden Knoten verbunden sind. Für jeden Knoten in der verknüpften Liste müssen wir Daten und zwei Punkte speichern. Der Anfangsknoten ist Null und der folgende Punkt im letzten Knoten ist Null, um das Ende der verknüpften Liste auf beiden Seiten anzuzeigen.

Die doppelt verknüpfte Liste enthält auch vergleichbare Methoden zur Implementierung der einverknüpften Liste. Auch hier wird es für Sie ermüdend, die gleichen Dinge zu erklären. Gehen Sie den Code bei jedem Schritt durch und Sie werden ihn schnell verstehen.

Erstellt einen Knoten, der den vorherigen Knotenzeiger, Daten und einen nächsten Knotenzeiger für die doppelt verkettete Liste enthält.

class Node:
	def __init__(self, data):
		self.prev = None
		self.data = data
		self.next = None

class LinkedList:
	def __init__(self):
		self.head = None

class LinkedList:
	def insert(self, new_node):
		if self.head:
			last_node = self.head
			while last_node.next != None:
				last_node = last_node.next
			new_node.prev = last_node
			last_node.next = new_node

class LinkedList:
	def display(self):
		print("Normal Order: ", end='')
		temp_node = self.head
		while temp_node != None:
			print(temp_node.data, end=' ')
			temp_node = temp_node.next
		print()
		print("Reverse Order: ", end='')
		last_node = self.head
		while last_node.next != None:
			last_node = last_node.next
		temp_node = last_node
		while temp_node != None:
			print(temp_node.data, end=' ')
			temp_node = temp_node.prev
		print()