Datenstrukturen mit JavaScript: Einzelliste und doppelt verknüpfte Liste

In diesem Artikel werden einzelne und doppelt verknüpfte Listen untersucht, zwei grundlegende Datenstrukturen in der Informatik. Diese Strukturen werden oft missverstanden und werden am besten durch eine verlässliche Analogie verstanden: eine Schnitzeljagd.

Einzelverständnis Listen verstehen

Eine einzeln verknüpfte Liste ist eine Abfolge miteinander verbundener Knoten. Jeder Knoten enthält Daten und einen Zeiger, der den nächsten Knoten in der Sequenz verweist. Dies spiegelt eine Schnitzeljagd wider: Jeder Hinweis (Knoten) enthält eine Nachricht (Daten) und Anweisungen (Zeiger), die zum nächsten Hinweis führt. Die gesamte Folge von Hinweisen bildet die vollständige Jagd.

Einzeln verknüpfte Listenoperationen

Wir werden Operationen sowohl für den Node als auch für SinglyList (oder in unserem Fall DoublyList -Konstruktoren) untersuchen.

• Knoten: Ein grundlegender Baustein mit Daten.
• Doppelliste:
  • _length : verfolgt die Anzahl der Knoten.
  • head : zeigt auf den ersten Knoten.
  • tail : zeigt auf den letzten Knoten (ein wesentlicher Unterschied zu den einzelnen Listen).
  • add(value) : Fügt einen neuen Knoten hinzu.
  • searchNodeAt(position) : Findet einen Knoten in einem bestimmten Index.
  • remove(position) : Löscht einen Knoten bei einem bestimmten Index.

Implementierung von doppelt verknüpfter Listen

Implementieren wir eine DoublyList in JavaScript.

Erstens der Node :

 Klassenknoten {
  Konstruktor (Wert) {
    this.data = Wert;
    this.Previous = null; // Zeiger auf den vorherigen Knoten
    this.Next = null; // Zeiger auf den nächsten Knoten
  }
}

Der DoublyList :

 Klasse doppeltlist {
  constructor () {
    this._length = 0;
    this.head = null;
    this.tail = null;
  }
}

Doppelt verknüpfte Listenmethoden

Hier finden Sie Implementierungen von add(value) , searchNodeAt(position) und remove(position) , die für die bidirektionale Durchführung geändert werden.

add(value) :

 add (value) {
  const node = neuer Knoten (Wert);
  if (this._length) {
    this.tail.next = node;
    node.previous = this.tail;
    this.tail = node;
  } anders {
    this.head = node;
    this.tail = node;
  }
  this._length;
  Return Node;
}

searchNodeAt(position) : (identisch mit der Einzelversion mit der einzelnen Listen))

 SearchNodeat (Position) {
  // ... (Implementierung bleibt gleich) ...
}

remove(position) :

 entfernen (Position) {
  // ... (Implementierung ist komplexer, um vier Fälle zu behandeln: Ungültige Position, Kopf entfernen, Schwanz entfernen, einen mittleren Knoten entfernen. Siehe den ursprünglichen Artikel für die detaillierte Implementierung.) ...
}

Abschluss

Dieser Artikel lieferte eine klare Erläuterung einzeln und doppelt verknüpfter Listen unter Verwendung der Schnitzer -Hunt -Analogie. Der bereitgestellte JavaScript-Code demonstriert die Implementierung einer doppelt verknüpften Liste, wodurch die wichtigsten Unterschiede und Komplexitäten im Vergleich zu einer einzig verbundenen Liste hervorgehoben werden. Denken Sie daran, mit dem Code zu experimentieren, um Ihr Verständnis zu festigen.

Das obige ist der detaillierte Inhalt vonDatenstrukturen mit JavaScript: Einzelliste und doppelt verknüpfte Liste. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!