Comment implémenter une liste à chaînage unique en utilisant Python

Une liste chaînée unique est une structure de données commune qui se compose d'une série de nœuds, chaque nœud contient un élément et un pointeur vers le nœud suivant. Vous pouvez utiliser des classes pour implémenter des listes à chaînage unique en Python.

Tout d'abord, définissez une classe de nœud, qui contient un élément et un pointeur vers le nœud suivant :

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

où data représente l'élément du nœud, et next_node représente le pointage vers le bas . Un pointeur vers un nœud.

Ensuite, définissez une classe de liste chaînée unique, qui contient un nœud principal et quelques méthodes d'opération de base, telles que l'insertion, la suppression, la recherche et l'impression d'opérations de liste chaînée unique :

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

    def insert(self, data):
        new_node = Node(data)
        current_node = self.head
        while current_node.next_node is not None:
            current_node = current_node.next_node
        current_node.next_node = new_node

    def delete(self, data):
        current_node = self.head
        previous_node = None
        while current_node is not None:
            if current_node.data == data:
                if previous_node is not None:
                    previous_node.next_node = current_node.next_node
                else:
                    self.head = current_node.next_node
                return
            previous_node = current_node
            current_node = current_node.next_node

    def search(self, data):
        current_node = self.head
        while current_node is not None:
            if current_node.data == data:
                return True
            current_node = current_node.next_node
        return False

    def print_list(self):
        current_node = self.head.next_node
        while current_node is not None:
            print(current_node.data)
            current_node = current_node.next_node

#🎜🎜 #Dans le code ci-dessus, la méthode insert insère un nouveau nœud dans la queue de la liste à chaînage unique. La méthode delete supprimera le nœud où se trouve l'élément spécifié. La méthode de recherche est utilisée pour déterminer si un nœud existe dans une liste à chaînage unique. La méthode print_list est utilisée pour imprimer l’intégralité de la liste à chaînage unique.

Enfin, nous pouvons tester notre classe de liste à chaînage unique :

linked_list = LinkedList()
linked_list.insert(1)
linked_list.insert(2)
linked_list.insert(3)
linked_list.insert(4)

print(linked_list.search(3)) # True
print(linked_list.search(5)) # False

linked_list.delete(3)

linked_list.print_list() # 1 2 4

Ce qui précède sont les étapes de base pour implémenter une liste à chaînage unique à l'aide de Python. On peut voir que Python se caractérise par sa simplicité et sa facilité de compréhension, avec une petite quantité de code et sa facilité de lecture et de compréhension, ce qui fait de Python un langage de programmation très adapté à l'implémentation de structures de données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!