Linked List: Struktur Data Dinamis dengan Implementasi Singly, Doubly, dan Circular Linked List

Linked List adalah solusi untuk keterbatasan array — ukuran dinamis, insert/delete efisien di mana saja, tanpa perlu memindahkan elemen lain. Tapi ada trade-off: akses acak lebih lambat.

Konsep Dasar Linked List

Linked List adalah kumpulan node yang terhubung satu sama lain via pointer.

1
[data|next] → [data|next] → [data|next] → NULL
2
    10             20             30

Setiap node terdiri dari:

Data — nilai yang disimpan
Next pointer — alamat node berikutnya

Perbedaan Array vs Linked List

Aspek	Array	Linked List
Ukuran	Fixed (static)	Dynamic
Memori	Contiguous	Tersebar
Akses	O(1) — random access	O(n) — sequential
Insert/Delete	O(n) — geser elemen	O(1) — ubah pointer
Overhead	Tidak ada	Pointer per node

Singly Linked List

Setiap node hanya punya satu pointer ke node berikutnya.

1
HEAD → [10|→] → [20|→] → [30|→] → NULL

Struktur Node (C)

1
struct Node {
2
    int data;
3
    struct Node* next;
4
};

Operasi Dasar

Membuat Node Baru

1
struct Node* createNode(int data) {
2
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
3
    newNode->data = data;
4
    newNode->next = NULL;
5
    return newNode;
6
}

Insert di Awal (Prepend)

1
void insertFront(struct Node** head, int data) {
2
    struct Node* newNode = createNode(data);
3
    newNode->next = *head;
4
    *head = newNode;
5
}

Insert di Akhir (Append)

1
void insertEnd(struct Node** head, int data) {
2
    struct Node* newNode = createNode(data);
3
    if (*head == NULL) {
4
        *head = newNode;
5
        return;
6
    }
7
    struct Node* temp = *head;
8
    while (temp->next != NULL)
9
        temp = temp->next;
10
    temp->next = newNode;
11
}

Insert di Posisi Tertentu

1
void insertAt(struct Node** head, int pos, int data) {
2
    if (pos == 0) {
3
        insertFront(head, data);
4
        return;
5
    }
6
    struct Node* newNode = createNode(data);
7
    struct Node* temp = *head;
8
    for (int i = 0; i < pos - 1 && temp != NULL; i++)
9
        temp = temp->next;
10
    if (temp == NULL) return;
11
    newNode->next = temp->next;
12
    temp->next = newNode;
13
}

Delete Node

1
void deleteNode(struct Node** head, int data) {
2
    struct Node* temp = *head;
3

4
    // Hapus head
5
    if (temp != NULL && temp->data == data) {
6
        *head = temp->next;
7
        free(temp);
8
        return;
9
    }
10

11
    // Cari node
12
    struct Node* prev = NULL;
13
    while (temp != NULL && temp->data != data) {
14
        prev = temp;
15
        temp = temp->next;
16
    }
17
    if (temp == NULL) return;
18

19
    prev->next = temp->next;
20
    free(temp);
21
}

Traverse (Cetak Semua)

1
void printList(struct Node* head) {
2
    struct Node* temp = head;
3
    while (temp != NULL) {
4
        printf("%d → ", temp->data);
5
        temp = temp->next;
6
    }
7
    printf("NULL\n");
8
}

Linked List untuk Penjumlahan Polinomial

Linked List sangat cocok untuk representasi polinomial seperti 3x² + 2x + 1:

1
struct Term {
2
    int coeff;    // koefisien
3
    int exp;      // eksponen
4
    struct Term* next;
5
};
6

7
// 3x^2 + 2x + 1
8
// [3|2|→] → [2|1|→] → [1|0|→] → NULL

Penjumlahan dua polinomial:

1
struct Term* addPolynomial(struct Term* p1, struct Term* p2) {
2
    struct Term* result = NULL;
3

4
    while (p1 != NULL && p2 != NULL) {
5
        if (p1->exp == p2->exp) {
6
            // Eksponen sama: jumlahkan koefisien
7
            insertTerm(&result, p1->coeff + p2->coeff, p1->exp);
8
            p1 = p1->next;
9
            p2 = p2->next;
10
        } else if (p1->exp > p2->exp) {
11
            insertTerm(&result, p1->coeff, p1->exp);
12
            p1 = p1->next;
13
        } else {
14
            insertTerm(&result, p2->coeff, p2->exp);
15
            p2 = p2->next;
16
        }
17
    }
18
    // Sisakan yang tersisa
19
    while (p1 != NULL) { insertTerm(&result, p1->coeff, p1->exp); p1 = p1->next; }
20
    while (p2 != NULL) { insertTerm(&result, p2->coeff, p2->exp); p2 = p2->next; }
21
    return result;
22
}

Doubly Linked List

Setiap node punya dua pointer — ke node sebelumnya (prev) dan berikutnya (next).

1
NULL ← [←|10|→] ↔ [←|20|→] ↔ [←|30|→] → NULL

Struktur Node

1
struct DNode {
2
    int data;
3
    struct DNode* prev;
4
    struct DNode* next;
5
};

Keunggulan Doubly vs Singly

	Singly	Doubly
Traversal	Forward saja	Forward & backward
Delete node	Butuh pointer prev	Langsung dari node
Memori per node	1 pointer	2 pointer
Insert sebelum node	O(n)	O(1)

Insert di Doubly Linked List

1
void insertAfter(struct DNode* prev_node, int data) {
2
    struct DNode* newNode = (struct DNode*)malloc(sizeof(struct DNode));
3
    newNode->data = data;
4
    newNode->next = prev_node->next;
5
    newNode->prev = prev_node;
6

7
    if (prev_node->next != NULL)
8
        prev_node->next->prev = newNode;
9
    prev_node->next = newNode;
10
}

Circular Linked List

Node terakhir menunjuk kembali ke node pertama — membentuk lingkaran.

1
HEAD → [10|→] → [20|→] → [30|→]
2
          ↑________________________|

Penggunaan

Round-robin scheduling — giliran proses secara berputar
Music player — repeat playlist
Buffer ring — data streaming

1
// Traverse circular linked list
2
void printCircular(struct Node* head) {
3
    if (head == NULL) return;
4
    struct Node* temp = head;
5
    do {
6
        printf("%d → ", temp->data);
7
        temp = temp->next;
8
    } while (temp != head);
9
    printf("(kembali ke head)\n");
10
}

Linked Stack dan Queue

Stack dan Queue bisa diimplementasikan dengan Linked List untuk ukuran dinamis tanpa batasan MAXSIZE.

Linked Stack

1
// Push = insert di depan
2
void linkedPush(struct Node** top, int data) {
3
    struct Node* newNode = createNode(data);
4
    newNode->next = *top;
5
    *top = newNode;
6
}
7

8
// Pop = hapus dari depan
9
int linkedPop(struct Node** top) {
10
    if (*top == NULL) return -1;
11
    struct Node* temp = *top;
12
    int data = temp->data;
13
    *top = temp->next;
14
    free(temp);
15
    return data;
16
}

Linked Queue

1
struct Queue {
2
    struct Node* front;
3
    struct Node* rear;
4
};
5

6
void linkedEnqueue(struct Queue* q, int data) {
7
    struct Node* newNode = createNode(data);
8
    if (q->rear != NULL)
9
        q->rear->next = newNode;
10
    q->rear = newNode;
11
    if (q->front == NULL)
12
        q->front = newNode;
13
}
14

15
int linkedDequeue(struct Queue* q) {
16
    if (q->front == NULL) return -1;
17
    struct Node* temp = q->front;
18
    int data = temp->data;
19
    q->front = temp->next;
20
    if (q->front == NULL) q->rear = NULL;
21
    free(temp);
22
    return data;
23
}

Kesimpulan

Linked List memberikan fleksibilitas dinamis yang tidak dimiliki array. Pilih struktur yang tepat berdasarkan kebutuhan:

Array → akses acak sering, ukuran tetap
Singly Linked List → insert/delete di awal/akhir sering
Doubly Linked List → butuh traversal dua arah
Circular Linked List → aplikasi berputar (scheduling, buffer)

Di artikel berikutnya: Trees dan Graph — struktur data non-linear untuk hierarki dan jaringan.

Referensi: Data Structure and Algorithm, Unit I — Singly Linked List, Linked Stacks and Queues, Polynomial Addition.

Thanks for reading!

Linked List: Struktur Data Dinamis dengan Implementasi Singly, Doubly, dan Circular Linked List

Mon Jun 29 2026

863 words · 8 minutes

Teknologi StrukturData LinkedList Pointer Algorithm C DataStructure DynamicMemory