Algorithmen und Datenstrukturen in JavaScript: Ein vollständiger Leitfaden für Node.js

Algorithmen und Datenstrukturen in JavaScript (Node.js): Von den Grundlagen bis zu fortgeschrittenen Techniken

Das Verständnis von Algorithmen und Datenstrukturen ist eine grundlegende Fähigkeit für jeden Entwickler, der mit JavaScript arbeitet, insbesondere in der Node.js-Umgebung. Ohne dieses Wissen ist es unmöglich, effiziente, skalierbare und schnelle Anwendungen zu erstellen. In diesem Artikel werden wir die wichtigsten Konzepte behandeln, die Ihnen helfen, optimierten Code zu schreiben und technische Vorstellungsgespräche erfolgreich zu bestehen.

Warum sind Algorithmen und Datenstrukturen für Node.js wichtig?

Node.js, das auf der V8-Engine basiert, ermöglicht die Ausführung von JavaScript auf dem Server. Hier, anders als im Browser, ist die Leistung von entscheidender Bedeutung: Der Server verarbeitet Tausende von Anfragen gleichzeitig. Die falsche Wahl der Datenstruktur kann zu einer Verlangsamung um das Hundertfache führen. Beispielsweise kann die Suche nach einem Element in einem Array mit 10.000 Einträgen 0,1 ms dauern, in einer verketteten Liste jedoch 10 ms. Der Unterschied ist offensichtlich.

Die wichtigsten Datenstrukturen, die Sie verwenden werden:

• Arrays — ein grundlegendes, aber leistungsstarkes Werkzeug. Schneller Zugriff über den Index (O(1)), aber langsames Einfügen/Löschen am Anfang (O(n)).
• Hash-Tabellen (Object, Map) — ideal zum Speichern von Schlüssel-Wert-Paaren. Durchschnittliche Komplexität der Operationen ist O(1).
• Verkettete Listen (LinkedList) — effizient für häufige Einfügungen und Löschungen in der Mitte der Liste.
• Stapel und Warteschlangen (Stack, Queue) — unverzichtbar bei der Verarbeitung von Datenströmen (z. B. Aufgaben in der Event Loop).
• Bäume (Binary Tree, BST) — für hierarchische Daten und schnelle Suche.
• Graphen (Graph) — zur Modellierung von Beziehungen (soziale Netzwerke, Routen).

Grundlegende Sortier- und Suchalgorithmen in JavaScript

Betrachten wir zwei klassische Aufgaben: das Sortieren eines Arrays und die binäre Suche. In Node.js werden diese Algorithmen direkt ohne externe Bibliotheken implementiert.

Quick Sort

Dies ist einer der effizientesten Algorithmen mit einer durchschnittlichen Komplexität von O(n log n). Er arbeitet nach dem Prinzip "Teile und Herrsche".

function quickSort(arr) {  if (arr.length <= 1) return arr;

  const pivot = arr[arr.length - 1];  const left = [];  const right = [];

  for (let i = 0; i < arr.length - 1; i++) {    if (arr[i] < pivot) {      left.push(arr[i]);    } else {      right.push(arr[i]);    }  }

  return [...quickSort(left), pivot, ...quickSort(right)];}

// Beispiel zur Verwendungconst numbers = [34, 7, 23, 32, 5, 62];console.log(quickSort(numbers)); // [5, 7, 23, 32, 34, 62]

Binary Search

Ein Algorithmus für sortierte Arrays. Komplexität O(log n) — um Größenordnungen schneller als die lineare Suche.

function binarySearch(arr, target) {  let left = 0;  let right = arr.length - 1;

  while (left <= right) {    const mid = Math.floor((left + right) / 2);

    if (arr[mid] === target) return mid;    if (arr[mid] < target) left = mid + 1;    else right = mid - 1;  }

  return -1; // Element nicht gefunden}

const sortedArray = [1, 3, 5, 7, 9, 11, 13];console.log(binarySearch(sortedArray, 7)); // 3

Hash-Tabellen: Wenn Leistung zählt

In Node.js werden Hash-Tabellen über die integrierten Objekte Map und Object implementiert. Sie ermöglichen den Datenzugriff im Durchschnitt in O(1). Es ist jedoch wichtig zu verstehen, wie man Kollisionen und Leistungseinbußen vermeidet.

Beispiel: Wortfrequenzzählung mit Map

function countWords(text) {  const wordMap = new Map();  const words = text.toLowerCase().split(/\\W+/);

  for (const word of words) {    if (word) {      wordMap.set(word, (wordMap.get(word) || 0) + 1);    }  }

  return wordMap;}

const text = "JavaScript und Node.js. JavaScript — ist eine Programmiersprache";