TypeScript Academy · Lektion

Baumstrukturen typisieren

Modellieren Sie verschachtelte Baumknoten mit rekursiven Typen.

Baumstrukturen typisieren ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Der Typ eines Baumknotens

Bäume verallgemeinern Listen: Jeder Knoten enthält einen Wert und ein Array untergeordneter Knoten desselben Typs. Dies ist ein rekursiver Typ mit einem children-Array.

type TreeNode<T> = {
  value: T;
  children: TreeNode<T>[];
};
const leaf: TreeNode<number> = { value: 1, children: [] };
console.log(leaf.value);

Einen kleinen Baum erstellen

Ein Knoten mit untergeordneten Knoten besteht einfach aus verschachtelten Objekten. Das leere Array ist der natürliche Basisfall für ein Blatt.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
const tree: TreeNode<string> = {
  value: "root",
  children: [
    { value: "a", children: [] },
    { value: "b", children: [] }
  ]
};
console.log(tree.children.length);

Tiefer verschachteln

Untergeordnete Knoten können beliebig tief eigene untergeordnete Knoten haben, weil jeder untergeordnete Knoten selbst ein vollständiger TreeNode ist.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
const tree: TreeNode<number> = {
  value: 1,
  children: [
    { value: 2, children: [{ value: 4, children: [] }] },
    { value: 3, children: [] }
  ]
};
console.log(tree.children[0].children[0].value);

Alle Werte summieren

Eine rekursive Funktion besucht jeden Knoten und ruft sich für dessen untergeordnete Knoten erneut auf, während sie ein Ergebnis akkumuliert – eine Tiefensuche.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function sum(node: TreeNode<number>): number {
  let total = node.value;
  for (const child of node.children) total += sum(child);
  return total;
}
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [] }, { value: 3, children: [] }] };
console.log(sum(t));

Knoten zählen

Dieselbe Traversierungsstruktur zählt Knoten: einen für den aktuellen Knoten plus die Anzahl aller Teilbäume.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function count<T>(node: TreeNode<T>): number {
  return 1 + node.children.reduce((acc, c) => acc + count(c), 0);
}
const t: TreeNode<string> = { value: "r", children: [{ value: "a", children: [] }] };
console.log(count(t));

Maximale Tiefe ermitteln

Die Tiefe ist eins plus die maximale Tiefe der Kindknoten oder bei einem Blatt ohne Kinder eins.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function depth<T>(node: TreeNode<T>): number {
  if (node.children.length === 0) return 1;
  return 1 + Math.max(...node.children.map(depth));
}
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [{ value: 3, children: [] }] }] };
console.log(depth(t));

Alle Werte sammeln

Flachen Sie einen Baum zu einem Array ab, indem Sie den aktuellen Wert mit den abgeflachten Kindern verketten.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function flatten<T>(node: TreeNode<T>): T[] {
  return [node.value, ...node.children.flatMap(flatten)];
}
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [] }, { value: 3, children: [] }] };
console.log(flatten(t));

Den Baum durchsuchen

Eine rekursive Suche gibt den ersten Knoten zurück, der einem Prädikat entspricht, und durchsucht die Kinder, wenn der aktuelle Knoten nicht übereinstimmt.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function find<T>(node: TreeNode<T>, pred: (v: T) => boolean): TreeNode<T> | null {
  if (pred(node.value)) return node;
  for (const c of node.children) {
    const hit = find(c, pred);
    if (hit) return hit;
  }
  return null;
}
const t: TreeNode<number> = { value: 1, children: [{ value: 5, children: [] }] };
console.log(find(t, v => v === 5)?.value);

Einen Baum abbilden

Transformieren Sie jeden Wert und erhalten Sie dabei die Struktur, indem Sie den Wert und die Kinder rekursiv abbilden.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function mapTree<T, U>(node: TreeNode<T>, fn: (v: T) => U): TreeNode<U> {
  return { value: fn(node.value), children: node.children.map(c => mapTree(c, fn)) };
}
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [] }] };
console.log(mapTree(t, x => x * 100).value);

Bäume modellieren reale Daten

Dateisysteme, DOM-Bäume, Organigramme und ASTs sind allesamt Bäume. Ein einziger rekursiver Typ beschreibt sie alle mit vollständiger Typsicherheit.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
type FileTree = TreeNode<string>;
const fs: FileTree = { value: "/", children: [{ value: "home", children: [] }] };
console.log(fs.value, fs.children[0].value);

Blätter und Verzweigungen

Ein Knoten ist ein Blatt, wenn children leer ist, und andernfalls eine Verzweigung. Diese Unterscheidung bestimmt oft die Traversierungslogik.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function isLeaf<T>(node: TreeNode<T>): boolean {
  return node.children.length === 0;
}
console.log(isLeaf({ value: 1, children: [] }));

Schnelltest: Baumstrukturen

Testen Sie Ihr Verständnis für die Typisierung von Baumstrukturen.

Zusammenfassung: Baumstrukturen typisieren

Sie haben Bäume mit TreeNode<T> modelliert, wobei jeder Knoten einen Wert und ein Array von Kindknoten enthält. Anschließend haben Sie rekursive Funktionen geschrieben, um Werte zu summieren und zu zählen, zu suchen und sie abzubilden.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [] }] };
console.log(t.children[0].value);

Häufig gestellte Fragen

Ist die Lektion „Baumstrukturen typisieren“ kostenlos?

Ja — der vollständige Text von „Baumstrukturen typisieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Baumstrukturen typisieren“?

Modellieren Sie verschachtelte Baumknoten mit rekursiven Typen. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Baumstrukturen typisieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu TypeScript Academy