Una lista enlazada consta de nodos y enlaces dirigidos. Entonces podemos generar dos clases: clase de nodo y clase de operación de lista enlazada unidireccional.
Clase de nodo:
La clase de nodo se usa para construir los nodos de la lista enlazada individualmente, y un nodo contiene dos partes: valor y apuntamiento. (Suponga que la clase de nodo no es direccional, por lo que el siguiente parámetro predeterminado es Ninguno)
class Node:
def __init__(self, val, next=None):
self.val = val #将val传入的值赋给self.val
self.next = next #next始终为None，不具备指向性，在实例化时进行指向El siguiente es un ejemplo de instanciación:
Cree el nodo1 (val=1), el nodo2 (val=2) y apunte el nodo1 al nodo2.
node1 = Node(1) # ①
node2 = Node(2) # ②
node1.next = node2 # ③
Clase de lista enlazada unidireccional:
Al crear una clase de lista enlazada individualmente, primero debemos crear un nodo principal, que solo representa el comienzo de una lista enlazada, por lo que no se requiere ninguna asignación.
1. Cree un nodo principal:
class LinkList:
def __init__(self):
self.head = Node(None) # 通过之前的Node类创建一个链表的头结点
El siguiente es un ejemplo de instanciación:
Cree una lista enlazada individualmente con un encabezado y un nodo.
Idea: primero genera un nodo principal, un nodo, y luego apunta el nodo principal al nodo.
l = LinkList() # 用l将linklist实例化，之后l就具有了linklist所具有的属性
node = Node(1) # 生成节点
l.head.next = node # l.head就是生成的头节点：Node(none)，图中用node_head表示
# .next表示将头节点指向node
De la figura anterior, ¿cómo encontrar el nodo a través del nodo principal? —— ¿Cómo accede l.head.next al valor del nodo? -l.cabeza.siguiente.val
2. Convierta la lista en una lista enlazada:
Idea: Al acceder a la lista, agregue nodos a los valores en cada lista en un bucle. Introducimos una variable temporal p para representar el nodo alcanzado actualmente. Al principio p está en el nodo principal, agregue el nodo1 para el nodo principal, luego p se mueve al nodo1, agrega el nodo2 para el nodo1, luego p se mueve al nodo2, agrega el nodo3 para el nodo2... hasta que los elementos de la lista se agreguen.
# 将列表转换为链表
def init_list(self, list_):
p = self.head # 将头节点赋给p
for item in list_: # 循环遍历列表
p.next = Node(item) # 将下一个节点添加在当前节点（p）之后
p = p.next # 将p移动到下一个节点3. Recorra la lista enlazada y devuelva el valor
# 遍历列表并返回值
def show(self):
p = self.head.next
while p is not None:
print(p.val)
p = p.next4. Borrar todas las listas vinculadas
Idea: simplemente configure el siguiente nodo principal en Ninguno. Python limpiará los datos restantes por sí mismo.
# 清空全部链表
def clear(self):
self.head.next = None5. Comprueba si está vacío
# 检查链表是否为空
def is_empty(self):
if self.head.next is None:
return True
else:
return False6. Insertar
① Método de taponamiento de cola:
Idea: atravesar p hasta el último nodo y agregar un nodo después del último nodo
# 在链表末尾插入一个节点
def append(self, val):
p = self.head
while p.next is not None:
p = p.next
p.next = Node(val)②Método de inserción de la cabeza:
Idea: Apunte el siguiente nodo del nodo que se insertará al siguiente nodo del nodo principal y apunte el siguiente nodo del nodo principal a este nodo.
def head_insert(self, val):
node = Node(val) # ①
node.next = self.head.next # ②
self.head.next = node # ③③ Método de inserción aleatoria:
Idea: Introduzca una variable temporal p para indicar la posición actual del nodo. Mueva p a la posición de índice-1 y use la misma idea que el método de inserción de la cabeza para insertar.
# 在index处插入节点
def insert(self, index, val):
p = self.head
for i in range(index):
if p.next is None:
break
p = p.next
node = Node(val)
node.next = p.next
p.next = node7. Pase en la posición del nodo y obtenga el valor correspondiente
def get_index(self, index):
p = self.head.next
for i in range(index):
if p.next is None:
raise IndexError("list index is out of range")
p = p.next
return p.val8. Operación de eliminación de nodos (eliminación por valor)
def delete(self, x):
p = self.head
while p.next and p.next.val != x:
p = p.next
if p.next is None:
raise ValueError("x is not found")
else:
p.next = p.next.next
