Giriş

Öğrenme Çıktıları

Öncelikli Kuyruk ADT

Öncelikli Kuyruk (Priority Queue)

• Her öğenin bir önceliği (anahtarı) vardır; öğeler öncelik sırasına göre çıkar.
• Geliş sırası değil, öncelik belirleyicidir: ambulans trafikte öne geçer.
• Öncelikli işlerin yönetiminde kullanılır: görev çizelgeleme, acil servis, olay simülasyonu.
• En yüksek öncelikli öğeye bakmak O(1); onu çıkarmak ise uygulamaya bağlıdır (heap ile O(log n)).

Öncelikli Kuyruk ADT

Temel Kavramlar

Öncelikli Kuyruk ADT

Kuyruk mu, Öncelikli Kuyruk mu?

Acil servise sırasıyla dört hasta geliyor (küçük sayı = daha acil):

Öncelikli Kuyruk ADT

Kullanım Alanları

Öncelikli Kuyruk ADT

Temel İşlemler

public interface PriorityQueue<K, V> {
    void insert(K key, V value);
    Entry<K, V> min();        // boşsa null
    Entry<K, V> removeMin();  // boşsa null
    int size();
    boolean isEmpty();
}

Öncelikli Kuyruk ADT

Örnek İşlem Dizisi (min-öncelikli)

Liste ile Uygulama

Sırasız Liste ve Sıralı Liste

Liste ile Uygulama

Dizi ve Bağlı Liste Temsili

Liste ile Uygulama

Maliyet Karşılaştırması

* Önce sıralayarak.   ** Aşağıdan yukarıya heap oluşturma ile (bu bölümün sonunda).

İkili Heap

İkili Heap (Binary Heap)

Öncelikli kuyruğu uygulamak için en yaygın veri yapısıdır. İki koşulu birlikte sağlayan bir ikili ağaçtır:

İkili Heap

Min-Heap ve Max-Heap

• Sıra yalnızca ebeveyn–çocuk arasında geçerlidir: min-heap'te 7 ile 3 kardeştir, 7 > 3 olması sorun değildir.
• Kökten herhangi bir yaprağa giden her yol sıralıdır (min-heap'te artan, max-heap'te azalan).

İkili Heap

Tam İkili Ağaç (Complete Binary Tree)

İkili Heap

Heap mi, Değil mi?

Her ağaç için karar verin: max-heap mi, min-heap mi, yoksa heap değil mi? Hangi özellik bozuluyor?

İkili Heap

Dizi Gösterimi

• Düğümler kökten başlayarak düzey düzey, soldan sağa (level order) diziye yazılır.
• Tam ağaç olduğu için dizide boşluk kalmaz; işaretçi (referans) gerekmez.

Düğümlerin yanındaki küçük sayılar dizideki indeksleridir. Bu sunumda indeksler 0'dan başlar; kök heap[0]'dadır.

İkili Heap

Ebeveyn ve Çocuk Hesaplamaları

• Java'da tam sayı bölmesi zaten aşağı yuvarlar: (i - 1) / 2. Çocuk yoksa 2i + 1 ≥ n olur.
• 1 tabanlı alternatif (orijinal sunum): heap[0] boş bırakılır; çocuklar 2k, 2k + 1; ebeveyn ⌊k/2⌋. İkisi eşdeğerdir, biri seçilip tutarlı kullanılmalıdır.

Ekleme ve Silme

Öğe Ekleme: Up-Heap (yüzdür, swim)

1. Yeni öğe ağacın ilk boş konumuna (son düzeyde en soldaki boş yer = heap[n]) eklenir. Ağaç tam kalır.
2. Heap-sıra özelliği bozulmuş olabilir: yeni öğe ebeveyninden büyükse (max-heap) yer değiştirilir.
3. Öğe köke ulaşana ya da ebeveyni kendisinden büyük/eşit olana kadar yukarı taşınır.

Ekleme ve Silme

Up-Heap Örneği: ekle(10), ekle(8)

Ekleme ve Silme

Boş Heap'e Art Arda Ekleme: 4, 5, 2, 6, 1, 3

Ekleme ve Silme

Max-Heap'e Ekleme: Java Kodu

public class MaxHeap {
    private int[] heap = new int[4];
    private int n = 0;             // eleman sayısı

    public void ekle(int x) {
        if (n == heap.length) buyut(2 * heap.length);
        heap[n] = x;                   // ilk boş konum
        n++;
        yuzdur(n - 1);
    }

    private void yuzdur(int k) {   // up-heap
        while (k > 0 && heap[(k - 1) / 2] < heap[k]) {
            yerDegistir(k, (k - 1) / 2);
            k = (k - 1) / 2;
        }
    }

Ekleme ve Silme

En Büyüğü Çıkarma: Down-Heap (batır, sink)

1. Kökteki öğe (en büyük) saklanır; döndürülecek değer budur.
2. Ağacın son öğesi (heap[n − 1]) köke taşınır, n bir azalır. Ağaç tam kalır.
3. Kök artık küçük bir değer taşıyabilir: büyük olan çocukla yer değiştirilir.
4. Öğe bir yaprağa ulaşana ya da her iki çocuğundan büyük/eşit olana kadar aşağı taşınır.

Ekleme ve Silme

Down-Heap Örneği: silMax()

Ekleme ve Silme

Art Arda İki silMax()

Ekleme ve Silme

En Büyüğü Çıkarma: Java Kodu

public int silMax() {
    if (n == 0) throw new NoSuchElementException();
    int max = heap[0];
    yerDegistir(0, n - 1);           // son öğe köke
    n--;
    batir(0);
    if (n > 0 && n == heap.length / 4)   // ¼ dolu
        kucult(heap.length / 2);
    return max;
}
private void batir(int k) {        // down-heap
    while (2 * k + 1 < n) {          // sol çocuk var mı?
        int j = 2 * k + 1;
        if (j + 1 < n && heap[j] < heap[j + 1]) j++;
        if (heap[k] >= heap[j]) break;
        yerDegistir(k, j);
        k = j;
    }
}

Ekleme ve Silme

Min-Heap: insert(1) ve removeMin()

Ekleme ve Silme

Heap İşlemlerinin Maliyeti

* Dizi büyütme/küçültme dahil amortize maliyet. Yükseklik ⌊log₂ n⌋: n = 10⁶ öğede en çok 19 yer değiştirme.

Heap Oluşturma ve Heap Sort

n Öğeden Heap Oluşturma

for (int i = n / 2 - 1; i >= 0; i--)   // son iç düğümden köke
    batir(i);                            // alt ağaçları heap olan i'yi batır

Heap Oluşturma ve Heap Sort

Aşağıdan Yukarıya Heap Oluşturma

Heap Oluşturma ve Heap Sort

Aşağıdan Yukarıya Oluşturma Neden O(n)?

Heap Oluşturma ve Heap Sort

Heap Sort (Öbek Sıralaması)

• Dizinin sonunda sıralı kısım büyür, başında heap küçülür; ek dizi gerekmez (yerinde, O(1) ek bellek).
• En kötü durumda bile O(n log n): hızlı sıralamanın (quick sort) O(n²) kötü durumu yoktur.
• Kararlı değildir (stable değil): eşit anahtarların göreli sırası değişebilir.
• Max-heap artan sıralama, min-heap azalan sıralama üretir.

Heap Oluşturma ve Heap Sort

Heap Sort Örneği

Heap Oluşturma ve Heap Sort

Heap Sort: Java Kodu

public static void heapSort(int[] a) {
    int n = a.length;
    for (int i = n / 2 - 1; i >= 0; i--) // 1) oluştur
        batir(a, i, n);
    for (int son = n - 1; son > 0; son--) { // 2) sırala
        yerDegistir(a, 0, son);   // en büyük sona
        batir(a, 0, son);         // heap boyutu = son
    }
}
static void batir(int[] a, int k, int n) {
    while (2 * k + 1 < n) {
        int j = 2 * k + 1;
        if (j + 1 < n && a[j] < a[j + 1]) j++;
        if (a[k] >= a[j]) break;
        yerDegistir(a, k, j);
        k = j;
    }
}

Heap Oluşturma ve Heap Sort

Öncelikli Kuyrukla Sıralama

Genel fikir: tüm öğeleri öncelikli kuyruğa ekle, sonra n kez removeMin ile sırayla çıkar. Hangi sıralamayı elde ettiğimiz uygulamaya bağlıdır:

Heap Oluşturma ve Heap Sort

Java'da Hazır Sınıf: PriorityQueue

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(5); pq.offer(1); pq.offer(8);
pq.peek();   // 1  (min-heap, O(1))
pq.poll();   // 1  (O(log n))

// max-heap için ters karşılaştırıcı
PriorityQueue<Integer> maxPq =
    new PriorityQueue<>(Comparator.reverseOrder());

// hasta: öncelik küçük olan önce
PriorityQueue<Hasta> acil = new PriorityQueue<>(
    Comparator.comparingInt(h -> h.oncelik));

Özet

Özet

Özet

Etkileşimli Simülatörler

Bu bölümdeki işlemleri kendi değerlerinizle adım adım deneyin:

Özet

Örnek Problemler

1. Boş bir max-heap'e sırasıyla 5, 12, 8, 3, 15, 10 ekleyin. Son dizi nedir?
2. 1. sorudaki heap'e bir kez silMax() uygulayın. Dönen değer ve yeni dizi nedir?
3. {3, 1, 6, 5, 2, 4} dizisini aşağıdan yukarıya yöntemle max-heap'e çevirin.
4. 0 tabanlı dizide indeks 13'teki düğümün ebeveyni ve çocukları hangi indekslerdedir?
5. {10, 7, 9, 8, 2, 5} bir max-heap midir? Değilse neden?
6. Bir min-heap'teki en büyük öğeyi bulmanın maliyeti nedir?

Özet

Kaynaklar

• Goodrich, Tamassia ve Goldwasser, Data Structures and Algorithms in Java, 6. baskı, 2014.
• Cormen, Leiserson, Rivest ve Stein, Introduction to Algorithms, 4. baskı, 2022.
• Oracle, Java SE 17 PriorityQueue API belgesi.