TypeScript Academy · Pelajaran

Menentukan Jenis Struktur Pohon

Modelkan simpul pohon bertingkat dengan jenis rekursif.

Menentukan Jenis Struktur Pohon adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar TypeScript Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus TypeScript Academy mencakup 4 pelajaran total.

Tipe Simpul Pohon

Pohon menggeneralisasi daftar: setiap simpul memiliki nilai dan array simpul child dengan tipe yang sama. Ini adalah tipe rekursif dengan array children.

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

Membangun Pohon Kecil

Simpul dengan child hanyalah objek bertingkat. Array kosong merupakan kasus dasar alami untuk leaf.

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);

Menyusun Tingkat yang Lebih Dalam

Child dapat memiliki child sendiri hingga kedalaman berapa pun, karena setiap child itu sendiri merupakan TreeNode lengkap.

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);

Menjumlahkan Semua Nilai

Fungsi rekursif mengunjungi setiap simpul dan melakukan rekursi ke dalam child-nya sambil mengakumulasikan hasil, yaitu penelusuran depth-first.

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));

Menghitung Simpul

Bentuk penelusuran yang sama dapat menghitung simpul: satu untuk simpul saat ini ditambah jumlah semua subpohon.

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));

Menemukan Kedalaman Maksimum

Kedalaman adalah satu ditambah kedalaman maksimum di antara anak-anaknya, atau satu untuk daun tanpa anak.

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));

Mengumpulkan Semua Nilai

Ratakan pohon menjadi larik dengan menggabungkan nilai saat ini dengan anak-anak yang telah diratakan.

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));

Menelusuri Pohon

Pencarian rekursif mengembalikan simpul pertama yang cocok dengan predikat, lalu menelusuri anak-anaknya jika simpul saat ini tidak cocok.

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);

Memetakan Pohon

Transformasikan setiap nilai sambil mempertahankan strukturnya dengan memetakan nilai dan anak-anak secara rekursif.

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);

Pohon Memodelkan Data Nyata

Sistem berkas, pohon DOM, bagan organisasi, dan pohon sintaksis abstrak (AST) semuanya merupakan pohon. Satu tipe rekursif dapat mencakup semuanya dengan keamanan tipe penuh.

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);

Daun dan Cabang

Simpul adalah daun ketika children kosong, dan merupakan cabang jika tidak. Pembedaan ini sering menentukan logika penelusuran.

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: [] }));

Pemeriksaan Singkat: Struktur Pohon

Uji pemahaman Anda tentang pengetikan struktur pohon.

Ringkasan: Mengetik Struktur Pohon

Anda memodelkan pohon dengan TreeNode<T>, yang setiap simpulnya memiliki nilai dan larik simpul anak, lalu menulis fungsi rekursif untuk menjumlahkan, menghitung, mencari, dan memetakan nilai di dalamnya.

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

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menentukan Jenis Struktur Pohon” gratis?

Ya — teks lengkap “Menentukan Jenis Struktur Pohon” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus TypeScript Academy, upgrade ke CoddyKit PRO. Kursus TypeScript Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menentukan Jenis Struktur Pohon”?

Modelkan simpul pohon bertingkat dengan jenis rekursif. Kamu berlatih TypeScript Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai TypeScript Academy?

Tidak diperlukan pengalaman sebelumnya. TypeScript Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Menentukan Jenis Struktur Pohon” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran TypeScript Academy ini?

Ya. Setiap pelajaran TypeScript Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke TypeScript Academy