Algorithmen und Datenstrukturen in TypeScript: Ein vollständiger Leitfaden

Einleitung: Warum sind Algorithmen und Datenstrukturen in TypeScript wichtig?

In der modernen Webentwicklung nimmt TypeScript eine führende Position ein, da es eine strenge Typisierung und leistungsstarke Werkzeuge für die Erstellung skalierbarer Anwendungen bietet. Allerdings ist selbst der eleganteste Code ohne das Verständnis fundamentaler Algorithmen und Datenstrukturen nicht effizient. Dieser Artikel ist Ihr Leitfaden in die Welt des optimierten Codes in TypeScript. Wir werden die wichtigsten Datenstrukturen analysieren, zeigen, wie man sie typsicher implementiert, und klassische Algorithmen betrachten. Nach der Lektüre werden Sie in der Lage sein, nicht nur funktionierenden, sondern auch schnellen und vorhersagbaren Code zu schreiben.

1. Grundlegende Datenstrukturen mit Typisierung

TypeScript ermöglicht es, streng zu definieren, welche Datentypen in einer Struktur gespeichert werden können. Dies verhindert Fehler bereits zur Kompilierzeit. Betrachten wir drei fundamentale Strukturen.

1.1. Stapel (Stack) – LIFO-Prinzip

Ein Stapel arbeitet nach dem Prinzip "Last In, First Out" (zuletzt herein, zuerst heraus). Er eignet sich ideal für Aufgaben, bei denen Aktionen rückgängig gemacht werden müssen (z. B. der Browserverlauf).

// Implementierung eines Stapels mit einem Generikum Tclass Stack<T> {    private items: T[] = [];

    push(item: T): void {        this.items.push(item);    }

    pop(): T | undefined {        return this.items.pop();    }

    peek(): T | undefined {        return this.items[this.items.length - 1];    }

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

// Beispiel zur Verwendungconst numberStack = new Stack<number>();numberStack.push(10);numberStack.push(20);console.log(numberStack.pop()); // 20

1.2. Warteschlange (Queue) – FIFO-Prinzip

Eine Warteschlange arbeitet nach dem Prinzip "First In, First Out" (zuerst herein, zuerst heraus). Sie wird zur Verarbeitung von Aufgaben in der Reihenfolge ihres Eingangs verwendet, z. B. in Nachrichtenwarteschlangensystemen.

class Queue<T> {    private items: T[] = [];

    enqueue(item: T): void {        this.items.push(item);    }

    dequeue(): T | undefined {        return this.items.shift();    }

    front(): T | undefined {        return this.items[0];    }

    size(): number {        return this.items.length;    }}

// Beispiel mit einem benutzerdefinierten Typinterface Task {    id: number;    name: string;}const taskQueue = new Queue<Task>();taskQueue.enqueue({ id: 1, name: 'Auftrag bearbeiten' });taskQueue.enqueue({ id: 2, name: 'E-Mail senden' });

1.3. Verkettete Liste (Linked List)

Eine verkettete Liste besteht aus Knoten, von denen jeder auf den nächsten verweist. Im Gegensatz zu einem Array erfordert das Einfügen und Löschen von Elementen in der Mitte der Liste kein Verschieben aller Elemente.

class ListNode<T> {    value: T;    next: ListNode<T> | null = null;

    constructor(value: T) {        this.value = value;    }}

class LinkedList<T> {    private head: ListNode<T> | null = null;

    add(value: T): void {        const newNode = new ListNode(value);        if (!this.head) {            this.head = newNode;            return;        }        let current = this.head;        while (current.next) {            current = current.next;        }        current.next = newNode;    }

    print(): void {        let current = this.head;        while (current) {            console.log(current.value);            current = current.next;        }    }}

// Verwendungconst list = new LinkedList<string>();list.add('TypeScript');list.add('Python');list.print(); // TypeScript, Python

2. Sortier- und Suchalgorithmen

Das Sortieren von Daten ist eine der häufigsten Operationen. TypeScript ermöglicht die Erstellung universeller Funktionen, die mit beliebigen Datentypen arbeiten.

2.1. Schnellsortierung (Quick Sort)

Einer der effizientesten Algorithmen mit