Une liste chaînée se compose de nœuds et de liens dirigés. Nous pouvons donc générer deux classes : la classe de nœud et la classe d'opération de liste liée à sens unique.
Classe de nœud :
La classe de nœud est utilisée pour construire les nœuds de la liste chaînée de manière simple, et un nœud contient deux parties : valeur et pointage. (Supposons que la classe de nœud n'est pas directionnelle, donc le paramètre suivant par défaut est Aucun)
class Node:
def __init__(self, val, next=None):
self.val = val #将val传入的值赋给self.val
self.next = next #next始终为None，不具备指向性，在实例化时进行指向Voici un exemple d'instanciation :
Créez node1 (val=1), node2 (val=2) et faites pointer node1 vers node2.
node1 = Node(1) # ①
node2 = Node(2) # ②
node1.next = node2 # ③
Classe de liste chaînée à sens unique :
Lors de la création d'une classe de liste chaînée, nous devons d'abord créer un nœud principal, qui ne représente que le début d'une liste chaînée, donc aucune affectation n'est requise.
1. Créez un nœud principal :
class LinkList:
def __init__(self):
self.head = Node(None) # 通过之前的Node类创建一个链表的头结点
Voici un exemple d'instanciation :
Créez une liste à liens simples avec un en-tête et un nœud.
Idée : générez d'abord un nœud principal, un nœud, puis pointez le nœud principal vers le nœud.
l = LinkList() # 用l将linklist实例化，之后l就具有了linklist所具有的属性
node = Node(1) # 生成节点
l.head.next = node # l.head就是生成的头节点：Node(none)，图中用node_head表示
# .next表示将头节点指向node
À partir de la figure ci-dessus, comment trouver le nœud via le nœud principal ? —— Comment l.head.next accède-t-il à la valeur de node ? -l.head.next.val
2. Convertissez la liste en liste liée :
Idée : En accédant à la liste, ajoutez des nœuds aux valeurs de chaque liste dans une boucle. Nous introduisons une variable temporaire p pour représenter le nœud actuellement atteint. Au début p est au nœud de tête, ajoutez node1 pour le nœud de tête, puis p se déplace vers node1, ajoute node2 pour node1, puis p se déplace vers node2, ajoute node3 pour node2... jusqu'à ce que les éléments de la liste All soient ajoutés.
# 将列表转换为链表
def init_list(self, list_):
p = self.head # 将头节点赋给p
for item in list_: # 循环遍历列表
p.next = Node(item) # 将下一个节点添加在当前节点（p）之后
p = p.next # 将p移动到下一个节点3. Parcourez la liste chaînée et renvoyez la valeur
# 遍历列表并返回值
def show(self):
p = self.head.next
while p is not None:
print(p.val)
p = p.next4. Effacer toutes les listes liées
Idée : Définissez simplement le nœud suivant du nœud principal sur Aucun. Python nettoiera les données restantes par lui-même.
# 清空全部链表
def clear(self):
self.head.next = None5. Vérifiez s'il est vide
# 检查链表是否为空
def is_empty(self):
if self.head.next is None:
return True
else:
return False6. Insérer
① Méthode de branchement de la queue :
Idée : traverser p jusqu'au dernier nœud et ajouter un nœud après le dernier nœud
# 在链表末尾插入一个节点
def append(self, val):
p = self.head
while p.next is not None:
p = p.next
p.next = Node(val)②Méthode d'insertion de la tête :
Idée : pointez le nœud suivant du nœud à insérer vers le nœud suivant du nœud principal, et pointez le nœud suivant du nœud principal vers ce nœud.
def head_insert(self, val):
node = Node(val) # ①
node.next = self.head.next # ②
self.head.next = node # ③③ Méthode d'insertion aléatoire :
Idée : Introduisez une variable temporaire p pour indiquer la position actuelle du nœud. Déplacez p à la position de l'index-1 et utilisez la même idée que la méthode d'insertion de la tête pour insérer.
# 在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. Passez la position du nœud et obtenez la valeur correspondante
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. Supprimer l'opération de nœud (supprimer par valeur)
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
