Les données ne sont pas enregistrées dans des emplacements de mémoire adjacents tels que des tableaux. Et chaque élément lié est appelé un nœud et connecté par les pointeurs. Head est le nœud initial dans la liste des liens. Dynamique est la taille de la liste associée. Ainsi, nous pouvons avoir le nombre de nœuds que nous voulons sans le stockage de l'appareil. Deux types de listes sont liés. Regardons la leçon approfondie une par une.

Liste à chaînage simple

Une liste chaînée a un seul pointeur dans la liste chaînée connecté au nœud suivant. Pour chaque nœud de la liste chaînée, nous devons stocker les données et le pointeur. Null car l'indicateur suivant pour la fin de la liste chaînée contient le nœud final de la liste chaînée.

Tout d'abord, le nœud de liste chaînée sera créé. Nous pouvons facilement construire le nœud avec la classe Python. La classe comprend des données et le pointeur de nœud suivant.

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

Liste doublement chaînée

Une liste doublement chaînée a deux indicateurs dans la liste chaînée qui sont connectés au nœud précédent. Pour chaque nœud de la liste chaînée, nous devons stocker des données et deux points. Le nœud initial est zéro et le point suivant dans le dernier nœud est zéro pour montrer la fin de la liste chaînée des deux côtés.

La liste à double chaînage contient également des méthodes comparables pour implémenter la liste à chaînage unique. Encore une fois, il sera fastidieux pour vous d'expliquer les mêmes choses. Parcourez le code à chaque étape et vous le comprendrez rapidement.

Crée un nœud contenant le pointeur de nœud précédent, des données et un pointeur de nœud suivant pour la liste à double chaînage.

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()