Structures de données avec JavaScript: liste liée à un seul lien et liste à double liaison

Cet article explore les listes individuellement et doublement liées, deux structures de données fondamentales en informatique. Souvent mal compris, ces structures sont mieux compris par une analogie relatable: une chasse au trésor.

Comprendre les listes liées uniquement

Une liste liée uniquement est une séquence de nœuds interconnectés. Chaque nœud contient des données et un pointeur faisant référence au nœud suivant dans la séquence. Cela reflète une chasse au trésor: chaque indice (nœud) contient un message (données) et des instructions (pointeur) menant à l'indice suivant. Toute la séquence d'indices forme la chasse complète.

Opérations de liste liée uniquement

Nous examinerons les opérations pour le Node et les constructeurs SinglyList (ou, dans notre cas, DoublyList ).

• Node: un bloc de construction de base contenant des données.
• DoublyList:
  • _length : suit le nombre de nœuds.
  • head : pointe vers le premier nœud.
  • tail : pointe vers le dernier nœud (une différence clé par rapport aux listes liées uniquement).
  • add(value) : ajoute un nouveau nœud.
  • searchNodeAt(position) : trouve un nœud à un index spécifique.
  • remove(position) : supprime un nœud à un index spécifique.

Implémentation de la liste liée à une double

Implémentez une DoublyList dans JavaScript.

Tout d'abord, le constructeur Node :

 classe node {
  constructeur (valeur) {
    this.data = valeur;
    this.previous = null; // pointeur vers le nœud précédent
    this.next = null; // pointeur vers le nœud suivant
  }
}

Le constructeur DoublyList :

 class doubleblyList {
  constructeur () {
    this._length = 0;
    this.head = null;
    this.tail = null;
  }
}

Méthodes de liste liée à double

Voici des implémentations d' add(value) , searchNodeAt(position) et remove(position) , modifiée pour la traversée bidirectionnelle.

add(value) :

 ajouter (valeur) {
  const node = new nœud (valeur);
  if (this._length) {
    this.tail.next = nœud;
    Node.Previous = this.tail;
    this.tail = nœud;
  } autre {
    this.head = nœud;
    this.tail = nœud;
  }
  this._length;
  Node de retour;
}

searchNodeAt(position) : (identique à la version liée à la liste individuelle)

 searchNodeat (position) {
  // ... (L'implémentation reste la même) ...
}

remove(position) :

 retirer (position) {
  // ... (L'implémentation est plus complexe, gérer quatre cas: position non valide, enlever la tête, supprimer la queue, supprimer un nœud central. Reportez-vous à l'article d'origine pour la mise en œuvre détaillée.) ...
}

Conclusion

Cet article a fourni une explication claire des listes liées individuellement et doublement, en utilisant l'analogie de la chasse au trésor. Le code JavaScript fourni démontre la mise en œuvre d'une liste liée à une liaison double, mettant en évidence les principales différences et complexités par rapport à une liste unique. N'oubliez pas d'expérimenter le code pour solidifier votre compréhension.

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!