So erstellen Sie Datenstrukturen mit JavaScript ES6-Klassen

Datenstrukturen sind ein grundlegender Aspekt der Informatik und Programmierung, unabhängig von der verwendeten Sprache. Wenn Sie diese gründlich kennen, können Sie Daten effizient organisieren, verwalten, speichern und ändern. Das Identifizieren der richtigen Datenstruktur für Ihren Anwendungsfall kann die Leistung erheblich verbessern.

JavaScript kommt jedoch standardmäßig nur mit primitiven Datenstrukturen wie Arrays und Objekten. Aber mit der Einführung von ECMAScript 6 (ES6)-Klassen können Sie jetzt mit Hilfe primitiver Datenstrukturen benutzerdefinierte Datenstrukturen wie Stacks und Warteschlangen erstellen.

---

---

Der beste Weg jemanden online zu finden

Stack-Datenstruktur

Die Stack-Datenstruktur ermöglicht es Ihnen, neue Daten im LIFO-Verfahren (last-in, first-out) auf die vorhandenen Daten zu schieben. Diese lineare Datenstruktur lässt sich anhand eines einfachen Beispiels leicht veranschaulichen. Stellen Sie sich einen Stapel Teller vor, der auf einem Tisch steht. Sie können nur oben im Stapel eine Platte hinzufügen oder entfernen.

So implementieren Sie die Stack-Datenstruktur mit JavaScript-Arrays und ES6-Klassen :

class Stack {
constructor() {
this.data = [];
this.top = -1;
}
}

Lassen Sie uns einige der Operationen untersuchen und erstellen, die Sie auf einem Stapel ausführen können.

Push-Betrieb

Die Push-Operation wird verwendet, um neue Daten in den Stack einzufügen. Sie müssen die Daten beim Aufrufen der Push-Methode als Parameter übergeben. Vor dem Einfügen der Daten wird der oberste Zeiger des Stapels um eins erhöht und die neuen Daten werden an der obersten Position eingefügt.

push(data) {
this.top++;
this.data[this.top] = data;
return this.data;
}

Pop-Operation

Die pop-Operation wird verwendet, um das oberste Datenelement des Stapels zu entfernen. Während dieser Operation wird der obere Zeiger um 1 reduziert.

---

---

pop() {
if (this.top <0) return undefined;
const poppedTop = this.data[this.top];
this.top--;
return poppedTop;
}

Peek-Operation

Die Peek-Operation wird verwendet, um den Wert an der Spitze des Stapels zurückzugeben. Der Zeitaufwand zum Abrufen dieser Daten beträgt O(1).

Erfahren Sie mehr: Was ist Big-O-Notation?

---

---

peek() {
return this.top >= 0 ? this.data[this.top] : undefined;
}

Datenstruktur verknüpfter Listen

Eine verkettete Liste ist eine lineare Datenstruktur, die aus zahlreichen Knoten besteht, die mit Hilfe von Zeigern miteinander verbunden sind. Jeder Knoten in der Liste enthält die Daten und eine Zeigervariable, die auf den nächsten Knoten in der Liste zeigt.

Mehr erfahren: Eine Einführung in Pointer für Programmierer

Im Gegensatz zu einem Stapel erfordern verknüpfte Listenimplementierungen in JavaScript zwei Klassen. Die erste Klasse ist die Knoten Klasse zum Erstellen eines Knotens, und die zweite Klasse ist die LinkedList -Klasse, um alle Operationen in der verknüpften Liste auszuführen. Der Kopfzeiger zeigt auf den ersten Knoten der verknüpften Liste, und der Endzeiger zeigt auf den letzten Knoten der verknüpften Liste.

class Node {
constructor(data, next = null) {
this.data = data;
this.next = next;
}
}
class LinkedList {
constructor() {
this.head = null;
this.tail = null;
this.size = 0;
}
}

Hier sind einige der wichtigsten Operationen, die Sie für eine verknüpfte Liste ausführen können:

Vorgang anhängen

Die Append-Operation wird verwendet, um am Ende der verknüpften Liste einen neuen Knoten hinzuzufügen. Sie müssen die Daten als Parameter zum Einfügen eines neuen Knotens übergeben. Erstellen Sie zunächst ein neues Knotenobjekt mit dem Neu Stichwort in JavaScript.

Wenn die verknüpfte Liste leer ist, zeigen sowohl der Kopf- als auch der Endzeiger auf den neuen Knoten. Andernfalls zeigt nur der Schwanzzeiger auf den neuen Knoten.

append(data) {
const newNode = new Node(data);
if (!this.head) {
this.head = newNode;
this.tail = newNode;
} else {
this.tail.next = newNode;
this.tail = newNode;
}
this.size++;
return this;
}

Einfügevorgang

Um einen neuen Knoten an einem bestimmten Index einzufügen, können Sie die Einfügeoperation verwenden. Diese Methode benötigt zwei Parameter: die einzufügenden Daten und den Index, an dem sie eingefügt werden sollen. Im schlimmsten Fall hat diese Methode eine Zeitkomplexität von O(N), da sie möglicherweise die gesamte Liste durchlaufen muss.

insert(data, index) {
if (index this.size) return undefined;
if (index === 0) {
this.head = new Node(data, this.head);
!this.tail ? (this.tail = this.head) : null;
this.size++;
return this;
}
if (index === this.size) return this.append(data);
let count = 0;
let beforeNode = this.head;
while (count !== index) {
beforeNode = beforeNode.next;
count++;
}
const newNode = new Node(data);
let afterNode = beforeNode.next;
newNode.next = afterNode;
beforeNode.next = newNode;
this.size++;
return this;
}

Vorgang löschen

Die Löschoperation durchläuft die verknüpfte Liste, um die Referenz auf den zu löschenden Knoten zu erhalten, und entfernt die Verknüpfung des vorherigen Knotens. Ähnlich wie die Einfügeoperation hat auch die Löschoperation im schlechtesten Fall eine Zeitkomplexität von O(N).

deleteNode(index) {
if (index === 0) {
const removedHead = this.head;
this.head = this.head.next;
this.size--;
this.size === 0 ? (this.tail = null) : null;
return removedHead;
}
if (index === this.size - 1) {
if (!this.head) return undefined;
let currentNode = this.head;
let newTail = currentNode;
while (currentNode.next) {
newTail = currentNode;
currentNode = currentNode.next;
}
this.tail = newTail;
this.tail.next = null;
this.size--;
this.size === 0 ? ([this.head, this.tail] = [null, null]) : null;
return currentNode;
}
if (index this.size - 1) return undefined;
let count = 0;
let beforeNode = this.head;
while (count !== index - 1) {
beforeNode = beforeNode.next;
count++;
}
const removedNode = beforeNode.next;
let afterNode = removedNode.next;
beforeNode.next = afterNode;
removedNode.next = null;
this.size--;
return removedNode;
}

Warteschlangendatenstruktur

Die Datenstruktur der Warteschlange ähnelt einer Gruppe von Personen, die in einer Warteschlange stehen. Die Person, die zuerst in die Warteschlange einsteigt, wird vor anderen bedient. In ähnlicher Weise folgt diese lineare Datenstruktur dem FIFO-Ansatz (first in, first out), um Daten einzufügen und zu entfernen. Diese Datenstruktur kann in JavaScript mithilfe einer verknüpften Liste auf folgende Weise neu erstellt werden:

class Queue {
constructor() {
this.front = null;
this.rear = null;
this.size = 0;
}
}

So können Sie in JavaScript Daten in eine Warteschlange einfügen und daraus entfernen:

warum sind meine mobilen daten so langsam

Enqueue-Vorgang

Die Einreihungsoperation fügt neue Daten in die Warteschlange ein. Wenn beim Aufrufen dieser Methode die Warteschlangendatenstruktur leer ist, zeigen sowohl der vordere als auch der hintere Zeiger auf den neu eingefügten Knoten in der Warteschlange. Wenn die Warteschlange nicht leer ist, wird der neue Knoten am Ende der Liste hinzugefügt und der hintere Zeiger zeigt auf diesen Knoten.

enqueue(data) {
const newNode = new Node(data);
if (!this.front) {
this.front = newNode;
this.rear = newNode;
} else {
this.rear.next = newNode;
this.rear = newNode;
}
this.size++;
return this;
}

Vorgang aus der Warteschlange entfernen

Die Dequeue-Operation entfernt das erste Element in der Warteschlange. Während der Dequeue-Operation wird der Kopfzeiger zum zweiten Knoten in der Liste bewegt. Dieser zweite Knoten wird nun zum Kopf der Warteschlange.

dequeue() {
if (!this.front) return undefined;
if (this.front === this.rear) this.rear = null;
const dequeuedNode = this.front;
this.front = this.front.next;
this.size--;
return dequeuedNode;
}

Der nächste Schritt nach Datenstrukturen

Datenstrukturen können ein schwierig zu verstehendes Konzept sein, insbesondere wenn Sie neu in der Programmierung sind. Aber genau wie bei jeder anderen Fähigkeit kann Ihnen Übung dabei helfen, die Effizienz, die sie beim Speichern und Verwalten von Daten in Ihren Anwendungen bietet, wirklich zu verstehen und zu schätzen.

Algorithmen sind genauso nützlich wie Datenstrukturen und könnten der nächste logische Schritt auf Ihrer Programmierreise werden. Warum also nicht mit einem Sortieralgorithmus wie Bubble Sort beginnen?

Teilen Teilen Tweet Email Eine Einführung in den Bubble-Sort-Algorithmus

Der Bubble-Sort-Algorithmus: eine ausgezeichnete Einführung in das Sortieren von Arrays.

Weiter lesen Verwandte Themen

• Programmierung
• JavaScript
• Programmierung
• Codierungs-Tutorials

Über den Autor Nitin Ranganath(31 veröffentlichte Artikel)

Nitin ist ein begeisterter Softwareentwickler und Student der Computertechnik, der Webanwendungen mit JavaScript-Technologien entwickelt. Er arbeitet als freiberuflicher Webentwickler und schreibt in seiner Freizeit gerne für Linux und Programmierung.

Mehr von Nitin Ranganath

Abonniere unseren Newsletter

Abonnieren Sie unseren Newsletter für technische Tipps, Rezensionen, kostenlose E-Books und exklusive Angebote!

Klicken Sie hier, um zu abonnieren