Comment implémenter une liste liée dans Python?

Comment implémenter une liste liée dans Python?

L'implémentation d'une liste liée dans Python implique la création d'une classe Node pour représenter chaque élément et une classe LinkedList pour gérer la liste dans son ensemble. Chaque Node contient les données et un pointeur vers le nœud suivant dans la séquence. La classe LinkedList comprend généralement des méthodes d'insertion, de suppression, de recherche et de traversée.

Voici une implémentation de base:

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

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

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        current = self.head
        while current.next:
            current = current.next
        current.next = new_node

    def prepend(self, data):
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node

    def delete_node(self, key):
        current = self.head
        if current and current.data == key:
            self.head = current.next
            current = None
            return

        prev = None
        while current and current.data != key:
            prev = current
            current = current.next

        if current is None:
            return

        prev.next = current.next
        current = None

    def print_list(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("None")

#Example Usage
llist = LinkedList()
llist.append(1)
llist.append(2)
llist.append(3)
llist.prepend(0)
llist.delete_node(2)
llist.print_list() # Output: 0 -> 1 -> 3 -> None

Cet exemple montre une liste individuelle (chaque nœud ne pointe que le suivant). Des listes doublement liées (nœuds pointent vers les nœuds suivants et précédents) sont également possibles, offrant différentes caractéristiques de performance pour certaines opérations.

Avantages et inconvénients des listes liées dans Python par rapport à d'autres structures de données

Avantages:

• Taille dynamique: CHARGED OUCHED OUCHED ORD>
Taille dynamique: les listes de liens: SHOIND ORCHED ou SHOLLING: SHOINGS CHARGINE: Taille dynamique: les listes de liens ou le linke Facilement pendant l'exécution, contrairement aux tableaux qui nécessitent une pré-allocation de la mémoire.
• Insertion et suppression efficaces:
L'insertion ou la suppression d'un nœud à n'importe quelle position dans une liste liée ne nécessite que quelques pointeurs, ce qui en fait des tableaux où les éléments peuvent avoir besoin d'être décalés. L'allocation de mémoire contigu, les listes liées peuvent être plus économes en mémoire que les tableaux, en particulier lorsqu'ils traitent des données clairsemées.
Les inconvénients:

L'accès aléatoire est inefficace:

Accédant à une opération spécifique dans une liste liée nécessite des parasites qui offrent un accès aléatoire o (1).
• Average de mémoire supplémentaire:
Chaque nœud nécessite une mémoire supplémentaire pour stocker le pointeur vers le nœud suivant.
• Implémentation plus complexe:
Listes liées sont généralement plus complexes pour mettre en œuvre et débogue que des tableaux ou d'autres structures de données. Les listes (qui sont des tableaux dynamiques), les piles, les files d'attente et les arbres, les listes liées excellent lorsque des insertions et des suppressions fréquentes sont nécessaires à des positions arbitraires. Cependant, si l'accès aléatoire est crucial, les tableaux ou les listes de python sont de bien meilleurs choix.
• Comment puis-je rechercher et supprimer efficacement les nœuds dans une implémentation de la liste liée à Python?
La recherche et la suppression des nœuds dans une liste liée impliquent intrinsèquement le trait. La recherche efficace signifie généralement minimiser le nombre de nœuds visités. Pour une liste individuelle, la recherche est intrinsèquement linéaire, o (n) complexité temporelle. La suppression d'un nœud nécessite de trouver le nœud à supprimer puis de mettre à jour les pointeurs de son prédécesseur et successeur.

La méthode delete_node dans l'exemple de code précédent démontre une suppression linéaire. Pour améliorer l'efficacité de la recherche, vous pouvez envisager d'utiliser un arbre de recherche binaire auto-équilibré ou une table de hachage si vous avez souvent besoin de rechercher des nœuds spécifiques. Cependant, ceux-ci nécessiteraient une restructuration significative de votre stockage de données.

Quels sont les cas d'utilisation courants pour les listes liées dans la programmation Python?

Les listes liées recherchent des applications dans des scénarios où l'insertion dynamique et la suppression sont plus important Mettez en œuvre ces structures de données fondamentales.

• Représentant les polynômes: Chaque nœud peut représenter un terme dans un polynôme (coefficient et exposant).
• Implémentation de la fonctionnalité UNDO / REDO: Une liste liée peut suivre les histoires des ajustements, permettant une autre annexe et une révocation. Players: A linked list can efficiently manage a playlist, allowing easy insertion and deletion of songs.
• Maintaining a Log of Events: Each node could represent an event with a timestamp.
• Graphs and Network Data Structures: Linked lists are used extensively in representing the adjacency lists of nodes in Les graphiques.
• Essentiellement, chaque fois que le coût du changement d'éléments dans un tableau (en raison des insertions / suppressions fréquents) l'emporte sur le coût de l'accès séquentiel, une liste liée est un concurrent fort.

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!