Os dados não são salvos em locais de memória adjacentes, como matrizes. E cada elemento vinculado é denominado um nó e conectado pelos ponteiros. Head é o nó inicial na lista de links. Dinâmico é o tamanho da lista associada. Portanto, podemos ter qualquer número de nós que quisermos sem o armazenamento do dispositivo. Dois tipos de listas estão conectados. Vamos dar uma olhada em uma lição completa.

Lista Ligada Individualmente

Uma lista vinculada possui um único ponteiro na lista vinculada conectado ao próximo nó. Para cada nó na lista vinculada, devemos armazenar os dados e o ponteiro. Nulo, pois o próximo indicador para o final da lista vinculada contém o nó final na lista vinculada.

Em primeiro lugar, o nó da lista vinculada será criado. Podemos construir o nó com a classe Python facilmente. A classe inclui dados e o próximo ponteiro de nó.

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

Lista duplamente vinculada

Uma lista duplamente vinculada possui dois indicadores na lista vinculada que estão conectados ao nó anterior. Para cada nó na lista vinculada, devemos armazenar dados e dois pontos. O nó inicial é zero e o ponto seguinte no último nó é zero para mostrar o final da lista encadeada em ambos os lados.

A lista de link duplo também contém métodos comparáveis ​​para implementar a lista de um link. Novamente, será cansativo para você explicar as mesmas coisas. Percorra o código em cada etapa e você o compreenderá rapidamente.

Cria um nó contendo o ponteiro do nó anterior, dados e um próximo ponteiro do nó para a lista dupla vinculada.

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