C Academy · Pelajaran

Linked List Satu Arah

Node dan pointer.

Linked List Satu Arah 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 daftar berantai?

Daftar berantai adalah rangkaian struktur kecil yang disebut simpul. Setiap simpul menyimpan nilai dan penunjuk ke simpul berikutnya.

Berbeda dari array, elemen-elemennya tidak harus bersebelahan di memori, dan daftar dapat bertambah atau berkurang dengan mudah.

#include <stdio.h>

struct Node {
    int value;
    struct Node *next;
};

int main(void) {
    printf("A node holds a value and a next pointer\n");
    return 0;
}

Mendefinisikan simpul

Struct simpul berisi data serta struct Node *next yang menunjuk ke simpul berikutnya.

Tipe penunjuk tersebut merujuk ke struct yang sama, sehingga rangkaian dapat saling terhubung.

#include <stdio.h>

struct Node {
    int value;
    struct Node *next;
};

int main(void) {
    struct Node n;
    n.value = 42;
    n.next = NULL;
    printf("value=%d, next is NULL: %d\n", n.value, n.next == NULL);
    return 0;
}

Penunjuk kepala

Sebuah daftar dikenali melalui satu penunjuk ke simpul pertamanya, yang disebut kepala.

Daftar kosong cukup berupa kepala yang sama dengan NULL.

#include <stdio.h>

struct Node { int value; struct Node *next; };

int main(void) {
    struct Node *head = NULL;
    printf("List is empty: %d\n", head == NULL);
    return 0;
}

Mengalokasikan simpul

Simpul biasanya dibuat di heap dengan malloc agar tetap ada setelah fungsi yang membuatnya selesai.

Selalu periksa nilai yang dikembalikan dan ingat untuk membebaskan simpul-simpul tersebut nanti.

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

struct Node { int value; struct Node *next; };

int main(void) {
    struct Node *n = malloc(sizeof(struct Node));
    n->value = 7;
    n->next = NULL;
    printf("%d\n", n->value);
    free(n);
    return 0;
}

Operator panah

Saat Anda memiliki penunjuk ke struct, gunakan -> untuk mengakses anggota. n->value berarti sama dengan (*n).value.

Anda akan sering sekali menggunakan operator panah pada daftar berantai.

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

struct Node { int value; struct Node *next; };

int main(void) {
    struct Node *n = malloc(sizeof(struct Node));
    n->value = 99;
    printf("%d\n", n->value);
    free(n);
    return 0;
}

Menghubungkan dua simpul

Untuk menghubungkan simpul, atur next pada simpul pertama agar menunjuk ke simpul kedua. next milik simpul terakhir tetap NULL untuk menandai akhir.

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

struct Node { int value; struct Node *next; };

int main(void) {
    struct Node *a = malloc(sizeof(struct Node));
    struct Node *b = malloc(sizeof(struct Node));
    a->value = 1; a->next = b;
    b->value = 2; b->next = NULL;
    printf("%d -> %d\n", a->value, a->next->value);
    free(a); free(b);
    return 0;
}

Pembantu untuk membuat simpul

Alokasi berulang-ulang merepotkan, jadi bungkuslah dalam fungsi pembantu yang mengalokasikan, menginisialisasi, dan mengembalikan simpul baru.

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

struct Node { int value; struct Node *next; };

struct Node *make(int v) {
    struct Node *n = malloc(sizeof(struct Node));
    n->value = v;
    n->next = NULL;
    return n;
}

int main(void) {
    struct Node *n = make(5);
    printf("%d\n", n->value);
    free(n);
    return 0;
}

Membangun daftar kecil

Dengan menggunakan pembantu tersebut, bangun daftar tiga simpul 1 -> 2 -> 3 dengan merangkai penunjuk next.

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

struct Node { int value; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->next=NULL;return n;}

int main(void) {
    struct Node *head = make(1);
    head->next = make(2);
    head->next->next = make(3);
    printf("%d %d %d\n", head->value, head->next->value, head->next->next->value);
    return 0;
}

Mencetak daftar

Untuk mencetak setiap nilai, mulai dari kepala dan ikuti penunjuk next sampai mencapai NULL.

Pola penelusuran ini menjadi dasar hampir semua operasi daftar.

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

struct Node { int value; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->next=NULL;return n;}

int main(void) {
    struct Node *head = make(1);
    head->next = make(2);
    for (struct Node *p = head; p; p = p->next)
        printf("%d ", p->value);
    printf("\n");
    return 0;
}

Array dibandingkan dengan daftar berantai

Array menyediakan akses indeks yang cepat, tetapi ukurannya tetap. Daftar berantai memudahkan penyisipan dan penghapusan, tetapi aksesnya lebih lambat karena Anda harus menelusuri daftar untuk mencapai suatu elemen.

Pilih berdasarkan operasi mana yang paling dominan dalam program Anda.

#include <stdio.h>

int main(void) {
    printf("Array: O(1) index, costly resize\n");
    printf("List:  O(n) index, cheap insert/delete\n");
    return 0;
}

Membebaskan seluruh daftar

Setiap simpul yang dialokasikan dengan malloc harus dibebaskan. Telusuri daftar, tetapi simpan penunjuk berikutnya sebelum membebaskan setiap simpul, atau sisa rantainya akan hilang.

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

struct Node { int value; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->next=NULL;return n;}

int main(void) {
    struct Node *head = make(1);
    head->next = make(2);
    struct Node *p = head;
    while (p) {
        struct Node *nxt = p->next;
        free(p);
        p = nxt;
    }
    printf("freed all nodes\n");
    return 0;
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang struktur daftar tertaut.

Ringkasan

Anda telah mempelajari dasar-dasar daftar tertaut tunggal:

Sebuah simpul menyimpan nilai dan penunjuk next; kepala menunjuk ke simpul pertama.
Alokasikan simpul dengan malloc dan akses anggotanya dengan ->.
next milik simpul terakhir adalah NULL; telusuri daftar dengan mengikuti penunjuk.
Selalu bebaskan setiap simpul dengan menyimpan next sebelum membebaskannya.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Linked List Satu Arah” gratis?

Ya — teks lengkap “Linked List Satu Arah” 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 “Linked List Satu Arah”?

Node dan 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 “Linked List Satu Arah” 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

← Kembali ke C Academy