Algorithmen und Datenstrukturen in JavaScript für Anfänger

Einleitung: Warum Algorithmen und Datenstrukturen in JavaScript lernen?

Jedes Programm ist nicht nur eine Sammlung von Anweisungen, sondern eine Möglichkeit, Daten effizient zu verwalten. Für angehende Entwickler in JavaScript (insbesondere in der Node.js-Umgebung) ist das Verständnis von Algorithmen und Datenstrukturen nicht nur eine akademische Aufgabe, sondern eine praktische Fähigkeit, die sich direkt auf die Leistung und Lesbarkeit des Codes auswirkt.

JavaScript ist eine dynamisch typisierte Sprache, aber das ändert nichts an der Notwendigkeit zu wissen, wie Arrays, Stacks oder Queues funktionieren. Ohne dieses Wissen kann Ihr Code langsam und die Logik unübersichtlich werden. In diesem Artikel behandeln wir grundlegende Datenstrukturen und Algorithmen anhand von Node.js-Beispielen, die Ihnen helfen, effizientere Anwendungen zu schreiben.

Grundlegende Datenstrukturen in JavaScript (Node.js)

JavaScript verfügt über mehrere eingebaute Datenstrukturen, aber für ein tiefes Verständnis ist es wichtig, sie manuell implementieren zu können. Dies gibt Ihnen Kontrolle über Speicher und Ausführungsgeschwindigkeit.

Arrays

Arrays in JS sind dynamische Listen. Sie eignen sich ideal zum Speichern geordneter Daten. Es ist jedoch wichtig zu bedenken, dass das Einfügen oder Entfernen eines Elements am Anfang des Arrays (unshift/shift) eine Operation mit O(n) ist, da alle Elemente verschoben werden müssen.

// Array erstellenconst fruits = ['apple', 'banana', 'cherry'];

// Am Ende hinzufügen (O(1))fruits.push('orange');

// Vom Ende entfernen (O(1))fruits.pop();

// Element suchen (O(n))const index = fruits.indexOf('banana');console.log(index); // 1

Stacks

Ein Stack arbeitet nach dem LIFO-Prinzip (Last In, First Out). Diese Struktur ist unverzichtbar für die Verarbeitung von Funktionsaufrufen, Rückgängig-Funktionen (Undo) oder die Überprüfung von Klammern im Code.

class Stack {    constructor() {        this.items = [];    }

    push(element) {        this.items.push(element);    }

    pop() {        if (this.isEmpty()) return null;        return this.items.pop();    }

    peek() {        return this.items[this.items.length - 1];    }

    isEmpty() {        return this.items.length === 0;    }}

// Beispiel: Klammerprüfungconst stack = new Stack();const str = '({[]})';let isValid = true;

for (let char of str) {    if (char === '(' || char === '{' || char === '[') {        stack.push(char);    } else {        const last = stack.pop();        if (            (char === ')' && last !== '(') ||            (char === '}' && last !== '{') ||            (char === ']' && last !== '[')        ) {            isValid = false;            break;        }    }}

console.log(isValid && stack.isEmpty()); // true

Queues

Eine Queue arbeitet nach dem FIFO-Prinzip (First In, First Out). Sie wird zur Aufgabenverwaltung, zur Verarbeitung von Anfragen in Node.js-Webservern oder zur Implementierung von Puffern verwendet.

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

    enqueue(element) {        this.items[this.rear] = element;        this.rear++;    }

    dequeue() {        if (this.isEmpty()) return null;        const item = this.items[this.front];        delete this.items[this.front];        this.front++;        return item;    }

    isEmpty() {        return this.front === this.rear;    }

    size() {        return this.rear - this.front;    }}

// Beispiel: Aufgabenverarbeitungconst taskQueue = new Queue();taskQueue.enqueue('Aufgabe 1');taskQueue.enqueue('Aufgabe 2');console.log(taskQueue.dequeue()); // Aufgabe 1

Suchalgorithmen in JavaScript

Die Datensuche ist eine der häufigsten Operationen. Betrachten wir zwei grundlegende Algorithmen: die lineare und die binäre Suche.

Lineare Suche (Linear Search)

Durchläuft die