Java Academy · Ders

LinkedList'in İç Yapısı

LinkedList'in çift bağlı düğüm yapısını ve zaman karmaşıklığı özelliklerini inceleyin.

LinkedList'in İç Yapısı, CoddyKit'te ücretsiz bir Java Academy dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Java Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Java Academy kursu toplamda 4 dersten oluşur.

LinkedList İç Yapısı

Java'daki LinkedList, çift bağlı bir listedir: her düğüm önceki ve sonraki düğüme bir başvuru ile öğe değerini tutar. ArrayList'ten farklı olarak destekleyici bir dizi yoktur — bellek her düğüm için ayrı ayrılır.

class Node<T> {
    T data;
    Node<T> prev;
    Node<T> next;
    Node(T data) { this.data = data; }
}

Zaman Karmaşıklığı Profili

LinkedList'in performans özellikleri ArrayList'ten önemli ölçüde farklıdır:

addFirst / addLast: O(1)
get(indeks): O(n) — baştan veya sondan geçmek gerekir
remove(indeks): bulmak için O(n), ardından bağlantıyı kaldırmak için O(1)
Yineleyici dolaşımı: O(n)

Sık sık listenin başına veya sonuna ekleme yapmanız gerektiğinde ve rastgele erişime ihtiyaç duymadığınızda LinkedList kullanın.

LinkedList Oluşturma ve Dolaşma

Bir LinkedList oluşturmak ve üzerinde yinelemek, zaten bildiğiniz aynı List arayüzünü izler. Fark, iç yapısındadır.

import java.util.LinkedList;

LinkedList<String> list = new LinkedList<>();
list.add("Alice");
list.add("Bob");
list.add("Carol");

for (String name : list) {
    System.out.println(name);
}

System.out.println("First: " + list.getFirst()); // Alice
System.out.println("Last: "  + list.getLast());  // Carol

addFirst, addLast, removeFirst, removeLast

LinkedList, ArrayList'in verimli biçimde sunmadığı baş ve son işlemlerini sağlar:

LinkedList<Integer> nums = new LinkedList<>();
nums.addLast(10);   // [10]
nums.addLast(20);   // [10, 20]
nums.addFirst(5);   // [5, 10, 20]

System.out.println(nums.removeFirst()); // 5  → [10, 20]
System.out.println(nums.removeLast());  // 20 → [10]

Düğüm Bağlantısını Kaldırma: Bulduktan Sonra O(1) Silme

Bir düğüme (yineleyici aracılığıyla) başvuru edindikten sonra silme işlemi O(1)'dir; çünkü yalnızca sonraki ve önceki işaretçilerin güncellenmesi gerekir — ArrayList'teki gibi öğeler kaydırılmaz.

import java.util.*;

LinkedList<String> tasks = new LinkedList<>(List.of("A","B","C","D"));
Iterator<String> it = tasks.iterator();
while (it.hasNext()) {
    String t = it.next();
    if (t.equals("B") || t.equals("D")) {
        it.remove(); // O(1) unlink
    }
}
System.out.println(tasks); // [A, C]

ArrayList'e Göre Bellek Ek Yükü

Her LinkedList düğümü iki ek başvuru (önceki, next) ve öğe başvurusunu taşır — 64 bitlik bir JVM'de giriş başına yaklaşık 48 bayt. ArrayList ise bitişik bir dizide yalnızca öğe başvurusunu (8 bayt) saklar.

Büyük ve okuma ağırlıklı veri kümelerinde ArrayList genellikle önbelleği daha verimli kullanır ve daha az bellek tüketir.

Çift Uçlu Kuyruk İşlemleri: Yığın ve Kuyruk

LinkedList, Deque arayüzünü uygular; bu nedenle hem yığın hem kuyruk olarak kullanılabilir.

import java.util.LinkedList;
import java.util.Deque;

// As a Queue (FIFO)
Deque<String> queue = new LinkedList<>();
queue.offer("first");
queue.offer("second");
System.out.println(queue.poll()); // first

// As a Stack (LIFO)
Deque<String> stack = new LinkedList<>();
stack.push("bottom");
stack.push("top");
System.out.println(stack.pop()); // top

PriorityQueue Genel Bakış

PriorityQueue, en küçük öğenin (doğal sıralamaya veya karşılaştırıcıya göre) her zaman ilk çıkarıldığı, yığın tabanlı bir kuyruktur. Bu yapı NOT bağlı listeyle desteklenmez — ikili yığın dizisi kullanır.

import java.util.PriorityQueue;

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(40);
pq.offer(10);
pq.offer(25);

System.out.println(pq.poll()); // 10 (smallest)
System.out.println(pq.poll()); // 25
System.out.println(pq.poll()); // 40

Özel Karşılaştırıcı ile PriorityQueue

Sıralamayı tersine çevirmek veya özel bir alana göre sıralamak için bir Comparator geçirin:

import java.util.*;

record Task(String name, int priority) {}

PriorityQueue<Task> tasks = new PriorityQueue<>(
    Comparator.comparingInt(Task::priority).reversed() // highest first
);
tasks.offer(new Task("Low", 1));
tasks.offer(new Task("High", 10));
tasks.offer(new Task("Med", 5));

while (!tasks.isEmpty()) {
    System.out.println(tasks.poll().name());
}
// High, Med, Low

LinkedList mi, ArrayList mi Seçilmeli

Genel kural:

Rastgele erişim, yineleme ve çoğu senaryo için ArrayList kullanın.
Her iki uçta da sık sık O(1) ekleme/silme yapmanız gerekiyor ve indeks erişimine ihtiyaç duymuyorsanız LinkedList kullanın.
Sıralı işlemeye ihtiyaç duyduğunuzda PriorityQueue kullanın (görev planlama, Dijkstra algoritması).

Yaygın Tuzaklar

Bir LinkedList üzerinde döngü içinde get(i) çağırmaktan kaçının — toplam karmaşıklık O(n²) olur:

LinkedList<Integer> list = new LinkedList<>();
for (int i = 0; i < 10000; i++) list.add(i);

// BAD: O(n^2) — each get(i) traverses from head
for (int i = 0; i < list.size(); i++) {
    int val = list.get(i); // slow!
}

// GOOD: O(n) — use iterator
for (int val : list) {
    // process val
}

Hızlı Kontrol

Liste boyutundan bağımsız olarak O(1) olan LinkedList işlemi hangisidir?

Özet: LinkedList ve Çift Uçlu Kuyruk

Ana çıkarımlar:

LinkedList, baş ve son işlemleri O(1) olan çift bağlı bir listedir
Rastgele erişim (indekse göre alma/ayarlama) O(n)'dir
Çift uçlu kuyruk arayüzünü uygular — yığın veya kuyruk olarak kullanılabilir
PriorityQueue, yığın sıralı işlemeyi sağlar
Çoğu kullanım için ArrayList'i tercih edin; LinkedList sık yapılan baş/son değişikliklerinde öne çıkar

Sıkça Sorulan Sorular

“LinkedList'in İç Yapısı” dersi ücretsiz mi?

Evet — “LinkedList'in İç Yapısı” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Java Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Java Academy kursu toplamda 4 dersten oluşur.

“LinkedList'in İç Yapısı” dersinde ne öğreneceğim?

LinkedList'in çift bağlı düğüm yapısını ve zaman karmaşıklığı özelliklerini inceleyin. Java Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Java Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Java Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“LinkedList'in İç Yapısı” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Java Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Java Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Java Academy Sayfasına Dön