0Pricing
C Academy · Pelajaran

Node dan Struktur Pohon

Modelkan node dengan pointer.

Node dan Struktur Pohon adalah pelajaran C Academy gratis di CoddyKit. Ini adalah pelajaran 1 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 C Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C Academy mencakup 4 pelajaran total.

Apa Itu Pohon Biner?

Pohon biner adalah struktur hierarkis yang setiap simpulnya menyimpan sebuah nilai dan terhubung ke paling banyak dua anak: anak kiri dan anak kanan.

Simpul yang paling atas adalah akar. Simpul tanpa anak disebut daun. Bentuk ini membuat pohon biner sangat baik untuk pencarian cepat, pengurutan, dan pemrosesan rekursif.

Struct Node

Dalam C, kita memodelkan sebuah simpul dengan struct yang menyimpan data serta dua penunjuk yang merujuk ke tipe itu sendiri.

Setiap penunjuk mengarah ke Node lain, atau ke NULL jika tidak ada anak di sisi tersebut.

struct Node {
    int value;
    struct Node *left;
    struct Node *right;
};

Mengapa Penunjuk Merujuk ke Tipe Itu Sendiri

Sebuah simpul tidak dapat berisi simpul lengkap lain berdasarkan nilai, karena hal itu memerlukan penyimpanan tak terbatas. Sebagai gantinya, simpul menyimpan penunjuk ke anak-anaknya.

Penunjuk memiliki ukuran tetap, sehingga struct tetap berukuran pasti sekaligus dapat dirangkai ke simpul-simpul lain di heap.

struct Node {
    int value;
    struct Node *left;   /* 8 bytes on 64-bit */
    struct Node *right;  /* 8 bytes on 64-bit */
};

typedef untuk Kemudahan

Mengetik struct Node di mana-mana merepotkan. typedef memungkinkan kita cukup menulis Node.

Tag tersebut tetap diperlukan di dalam struct karena pada titik itu tipe tersebut belum didefinisikan sepenuhnya.

typedef struct Node {
    int value;
    struct Node *left;
    struct Node *right;
} Node;

Mengalokasikan Node

Simpul berada di heap dan dibuat dengan malloc. Kita menetapkan nilainya dan menginisialisasi kedua penunjuk anak menjadi NULL.

Selalu periksa bahwa malloc tidak mengembalikan NULL sebelum menggunakan memori tersebut.

Node *create_node(int value) {
    Node *n = malloc(sizeof(Node));
    if (n == NULL) return NULL;
    n->value = value;
    n->left = NULL;
    n->right = NULL;
    return n;
}

Membangun Pohon Kecil Secara Manual

Untuk memahami hubungan antarpenunjuk, mari kita hubungkan tiga simpul secara manual: satu akar dengan dua anak.

Program ini membangun pohon dan mencetak nilai-nilainya, lalu biasanya kita akan membebaskannya (akan dibahas nanti).

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int value;
    struct Node *left;
    struct Node *right;
} Node;

Node *create_node(int v) {
    Node *n = malloc(sizeof(Node));
    n->value = v; n->left = NULL; n->right = NULL;
    return n;
}

int main(void) {
    Node *root = create_node(10);
    root->left = create_node(5);
    root->right = create_node(15);
    printf("%d %d %d\n", root->left->value, root->value, root->right->value);
    return 0;
}

Mencapai Cucu

Anda menelusuri pohon dengan merangkai operator panah. root->left->right bergerak turun ke anak kiri, lalu ke anak kanannya.

Sebelum mengikuti penunjuk, pastikan penunjuk tersebut bukan NULL, atau program Anda akan mengalami kerusakan.

/* root
 *   \
 *    right (15)
 *        \
 *         right->right (20)
 */
if (root->right != NULL && root->right->right != NULL)
    printf("%d\n", root->right->right->value);

Menghitung Simpul secara Rekursif

Rekursi cocok secara alami untuk pohon. Untuk menghitung simpul, subpohon kosong memiliki nol simpul; jika tidak kosong, hitung simpul ini ditambah kedua subpohonnya.

Pemeriksaan NULL adalah kasus dasar yang menghentikan rekursi.

int count_nodes(Node *root) {
    if (root == NULL) return 0;
    return 1 + count_nodes(root->left)
             + count_nodes(root->right);
}

Mengukur Tinggi

Tinggi pohon adalah jalur terpanjang dari akar hingga daun, yang diukur dalam jumlah sisi.

Kita mengambil tinggi yang lebih besar dari kedua subpohon lalu menambahkan satu. Pohon kosong diberi tinggi -1 sehingga satu simpul memiliki tinggi 0.

int height(Node *root) {
    if (root == NULL) return -1;
    int l = height(root->left);
    int r = height(root->right);
    return 1 + (l > r ? l : r);
}

Mengidentifikasi Daun

Daun adalah simpul tanpa anak: baik left maupun right bernilai NULL.

Pembantu kecil ini berguna dalam banyak rutin penelusuran dan penghitungan.

int is_leaf(Node *n) {
    return n != NULL && n->left == NULL && n->right == NULL;
}

Memanfaatkan Struktur

Di sini sebuah pohon kecil dibuat, lalu jumlah simpul dan tingginya dilaporkan menggunakan pembantu rekursif.

Perhatikan bahwa pembantu tersebut tidak pernah mengasumsikan bentuk tertentu; pembantu itu bekerja untuk pohon apa pun karena rekursi mengikuti penunjuk yang sebenarnya.

#include <stdio.h>
#include <stdlib.h>

typedef struct Node { int value; struct Node *left, *right; } Node;

Node *nn(int v){ Node *n=malloc(sizeof(Node)); n->value=v; n->left=n->right=NULL; return n; }
int count(Node *r){ return r? 1+count(r->left)+count(r->right):0; }
int height(Node *r){ if(!r) return -1; int l=height(r->left),x=height(r->right); return 1+(l>x?l:x); }

int main(void){
    Node *root = nn(10);
    root->left = nn(5); root->right = nn(15);
    root->left->left = nn(2);
    printf("nodes=%d height=%d\n", count(root), height(root));
    return 0;
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang struktur simpul.

Ringkasan

Simpul pohon biner menyimpan sebuah nilai dan dua penunjuk yang merujuk ke tipe itu sendiri (left, right), yang diatur menjadi NULL jika tidak ada.

Kita mengalokasikan simpul dengan malloc, menghubungkannya secara manual, lalu memprosesnya secara rekursif. Pemeriksaan NULL selalu menjadi kasus dasar untuk penghitungan, tinggi, dan pengujian daun.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Node dan Struktur Pohon” gratis?

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

Apa yang akan aku pelajari di “Node dan Struktur Pohon”?

Modelkan node dengan pointer. Kamu berlatih C 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 C Academy?

Tidak diperlukan pengalaman sebelumnya. C 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 1 dari 4.

Berapa lama pelajaran “Node dan 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 C Academy ini?

Ya. Setiap pelajaran C 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

  1. Node dan Struktur Pohon
  2. Menyisipkan ke BST
  3. Penelusuran
  4. Mencari dan Membebaskan Memori
← Kembali ke C Academy