Bidirektionale verknüpfte Liste der JavaScript-Datenstruktur

//Erstelle eine doppelt verkettete Liste Konstruktorfunktion DoublyLinkedList() {
 //Erstelle eine Knotenkonstruktorfunktion Node(element) {
  dieses.element = element
  dies.nächstes = null
  this.prev = null // Neu hinzugefügt}

 // Definieren Sie die Eigenschaft this.length = 0
 this.head = null
 this.tail = null // Neu hinzugefügt // Zugehörige Operationsmethoden definieren // Daten am Ende anhängen DoublyLinkedList.prototype.append = function (element) {
  // 1. Erstellen Sie einen Knoten basierend auf dem Element var newNode = new Node(element)

  // 2. Bestimmen Sie, ob die Liste eine leere Liste ist, wenn (this.head == null) {
   this.head = neuer Knoten
   this.tail = neuer Knoten
  } anders {
   this.tail.next = neuer Knoten
   neuerNode.prev = dieser.tail
   this.tail = neuer Knoten
  }

  // 3.Länge+1
  diese.Länge++
 }

 //Daten an beliebiger Position einfügen DoublyLinkedList.prototype.insert = function (position, element) {
  // 1. Bestimmen Sie das Problem außerhalb der Grenzen, wenn (Position < 0 || Position > this.length) false zurückgibt

  // 2. Einen neuen Knoten erstellen var newNode = new Node(element)

  // 3. Einfügeposition bestimmen if (position === 0) { // Daten an der ersten Position einfügen // Bestimmen, ob die verknüpfte Liste leer ist if (this.head == null) {
    this.head = neuer Knoten
    this.tail = neuer Knoten
   } anders {
    this.head.prev = neuer Knoten
    neuerNode.next = dieser.kopf
    this.head = neuer Knoten
   }
  } else if (position === this.length) { // Bis zum Ende einfügen // Überlegen: Müssen wir in diesem Fall prüfen, ob die verknüpfte Liste leer ist? Die Antwort lautet nein, warum?
   this.tail.next = neuer Knoten
   neuerNode.prev = dieser.tail
   this.tail = neuer Knoten
  } else { // Daten in der Mitte einfügen // Attribut definieren var index = 0
   var aktuell = dieser.kopf
   var vorherige = null

   // Finde die richtige Position while (index++ < position) {
    vorherige = aktuelle
    aktuell = aktuell.nächstes
   }

   //Die Zeigerreihenfolge der Knoten austauschen newNode.next = current
   newNode.prev = vorherige
   current.prev = neuer Knoten
   vorheriger.nächster = neuer Knoten
  }

  // 4.Länge+1
  diese.Länge++

  returniere wahr
 }

 // Lösche das entsprechende Element entsprechend der Position DoublyLinkedList.prototype.removeAt = function (position) {
  // 1. Bestimmen Sie das Problem außerhalb der Grenzen, wenn (Position < 0 || Position >= this.length) null zurückgibt

  // 2. Bestimmen Sie den zu entfernenden Ort var current = this.head
  wenn (Position === 0) {
   wenn (diese.Länge == 1) {
    this.head = null
    this.tail = null
   } anders {
    dieser.Kopf = dieser.Kopf.Nächster
    this.head.prev = null
   }
  } sonst wenn (Position === diese.Länge -1) {
   aktuell = dies.tail
   dies.tail = dies.tail.prev
   dies.tail.next = null
  } anders {
   Variablenindex = 0
   var vorherige = null

   während (Index++ < Position) {
    vorherige = aktuelle
    aktuell = aktuell.nächstes
   }

   vorheriges.nächstes = aktuelles.nächstes
   aktuell.nächstes.vorheriges = vorheriges
  }

  // 3.Länge-1
  diese.Länge--

  aktuelles Element zurückgeben
 }

 // Position des Elements in der verknüpften Liste abrufen DoublyLinkedList.prototype.indexOf = function (element) {
  // 1. Definieren Sie Variablen zum Speichern von Informationen var current = this.head
  Variablenindex = 0

  // 2. Finden Sie die richtigen Informationen, während (aktuell) {
   wenn (aktuelles.Element === Element) {
    Rückgabeindex
   }
   Index++
   aktuell = aktuell.nächstes
  }

  // 3. Wenn es an dieser Position nicht gefunden wird, geben Sie -1 zurück
  Rückgabe -1
 }

 // Löschen entsprechend dem Element DoublyLinkedList.prototype.remove = function (element) {
  var index = this.indexOf(element)
  gib dies zurück.removeAt(index)
 }

 // Prüfen, ob es leer ist DoublyLinkedList.prototype.isEmpty = function () {
  gib diese Länge zurück === 0
 }

 //Länge der verknüpften Liste abrufen DoublyLinkedList.prototype.size = function () {
  gib diese Länge zurück
 }

 // Holen Sie das erste Element DoublyLinkedList.prototype.getHead = function () {
  gib dieses.Kopfelement zurück
 }

 // Das letzte Element abrufen DoublyLinkedList.prototype.getTail = function () {
  gib dieses.tail.element zurück
 }

 // Implementierung der Traversierungsmethode // Vorwärts-Traversierungsmethode DoublyLinkedList.prototype.forwardString = function () {
  var aktuell = dieser.kopf
  var forwardStr = ""

  während (aktuell) {
   forwardStr += "," + aktuelles.element
   aktuell = aktuell.nächstes
  }

  returniere forwardStr.slice(1)
 }

 // Umgekehrte Durchquerungsmethode DoublyLinkedList.prototype.reverseString = function () {
  var aktuell = dies.tail
  var reverseStr = ""

  während (aktuell) {
   reverseStr += "," + aktuelles.element
   aktuell = aktuell.vorherige
  }

  returniere reverseStr.slice(1)
 }

 // Implementiere die toString-Methode DoublyLinkedList.prototype.toString = function () {
  gib dies zurück.forwardString()
 }
}