#1 Linked List
overview

#1 Linked List

Umam Alfarizi Umam Alfarizi
September 3, 2025
3 min read
linked-list

Setelah pemanasan dengan dasar-dasar Java, sekarang kita masuk ke salah satu struktur data yang paling fundamental, yaitu Linked List.

Gampangnya, bayangin aja Linked List itu kayak rangkaian gerbong kereta. Setiap gerbong (kita sebut node) bawa muatan (data) dan punya sambungan ke gerbong di belakangnya (next). Konsepnya mirip kayak pointer di C++, tapi di Java kita pakainya referensi objek buat nyambungin antar gerbongnya.

Konsep Dasar Linked List

Jadi, Linked List itu kumpulan node yang saling nyambung. Setiap node itu minimal punya dua hal: data yang disimpen, dan next yang jadi penunjuk ke node selanjutnya.

  [ Head ]
     |
     v
+------+------+   +------+------+   +------+------+
| Data | Next |-->| Data | Next |-->| Data | Next |--> null
+------+------+   +------+------+   +------+------+

Beda sama Array yang ukurannya harus ditentuin di awal, Linked List ini lebih fleksibel. Kita bisa nambah atau hapus data dengan gampang tanpa harus geser-geser elemen lain, cukup dengan ngubah sambungannya aja. Tapi, kekurangannya, kita nggak bisa langsung akses data di tengah. Kalau mau cari data ke-10, ya kita harus jalan dari gerbong paling depan satu per satu.

Bikin Cetakan Gerbong (Node)

Pertama, kita bikin dulu class buat Node-nya. Ini cetakan buat semua gerbong yang bakal kita buat nanti.

class Node {
    int data;
    Node next;


    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

1. Single Linked List (SLL)

Ini jenis Linked List yang paling dasar. Setiap gerbong cuma punya satu sambungan, yaitu ke gerbong berikutnya.

class LinkedList {
    Node head;


    void addLast(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            return;
        }
        Node current = head;
        while (current.next != null) {
            current = current.next;
        }
        current.next = newNode;
    }


    void printList() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }
}


public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.addLast(10);
        list.addLast(20);
        list.addLast(30);


        list.printList(); // Output: 10 -> 20 -> 30 -> null
    }
}

2. Double Linked List (DLL)

Nah, kalau di Double Linked List, gerbongnya lebih canggih. Selain punya sambungan ke gerbong belakang (next), dia juga punya sambungan ke gerbong depan (prev). Jadi kita bisa jalan-jalan maju-mundur di sepanjang rangkaian.

class NodeDLL {
    int data;
    NodeDLL prev, next;


    NodeDLL(int data) {
        this.data = data;
    }
}


class DoublyLinkedList {
    NodeDLL head;


    void addFirst(int data) {
        NodeDLL newNode = new NodeDLL(data);
        if (head != null) {
            head.prev = newNode;
            newNode.next = head;
        }
        head = newNode;
    }


    void printList() {
        NodeDLL current = head;
        while (current != null) {
            System.out.print(current.data + " <-> ");
            current = current.next;
        }
        System.out.println("null");
    }
}

Kalau dicoba, hasilnya bakal nunjukkin 30 <-> 20 <-> 10 <-> null karena kita nambahinnya dari depan terus.

3. Circular Linked List

Ini jenis yang unik. Gerbong paling belakang itu nggak berhenti di null, tapi nyambung lagi ke gerbong paling depan (head). Jadi kayak lingkaran, nggak ada ujungnya. Berguna banget buat bikin playlist lagu yang muter terus atau buat sistem antrean yang bergiliran.

class CircularLinkedList {
    Node head;


    void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            newNode.next = head;
            return;
        }
        Node current = head;
        while (current.next != head) {
            current = current.next;
        }
        current.next = newNode;
        newNode.next = head;
    }


    void printList(int n) {
        Node current = head;
        int count = 0;
        while (current != null && count < n) {
            System.out.print(current.data + " -> ");
            current = current.next;
            count++;
        }
        System.out.println("...");
    }
}

Kalau kita cetak beberapa kali, bakal kelihatan polanya muter terus, misalnya 1 -> 2 -> 3 -> 1 -> 2 -> 3 -> ...

Penutup Modul 1

Mantap! Kita udah ngulik soal Linked List, dari yang biasa, yang bisa maju-mundur, sampe yang muter-muter. Konsep ini penting banget, karena bakal jadi dasar buat ngertiin struktur data lain kayak stack dan queue yang bakal kita bahas di modul selanjutnya.

Discussion