Bölüm 16: Kümeler ve Union-Find

C ile Veri Yapıları ve Algoritmalar

Ayrık kümelerBirleşim ve küme bulmaata dizisiKötü durum O(n²)Ağırlıklı kuralAzaltma kuralıTers AckermannBileşen · Kruskal

Sercan KÜLCÜ · Giresun Üniversitesi · Bilgisayar Mühendisliği

Giriş

Öğrenme Çıktıları

Modellemek

İkili ayrık kümeleri çocuktan ataya bağlı ağaçlarla göstermek.

Gerçeklemek

Tek bir ata dizisiyle Kume_Bul ve Birlesim yordamlarını yazmak.

Kötü durumu bulmak

Hangi işlem dizisinin ağacı dejenere ettiğini ve O(n²) maliyeti göstermek.

İyileştirmek

Ağırlıklı kural ve azaltma (collapsing) kuralını uygulamak, lemmaları yorumlamak.

Analiz etmek

Tarjan–van Leeuwen sonucunu ve ters Ackermann fonksiyonunu açıklamak.

Kullanmak

Bağlantılı bileşen sayma ve Kruskal algoritmasında union-find'ı uygulamak.

Ayrık Kümeler

Kümelerde birleşim (union) ve bulma (find)

Evren {0, 1, …, n−1}; kümeler ikili ayrık (pairwise disjoint): S₁ ∩ S₂ = S₂ ∩ S₃ = S₁ ∩ S₃ = ∅. n = 10 için:

Her küme bir ağaçtır; bağlar çocuklardan atalara doğrudur (oklar yukarı).

Hocadan“Çok çok temel bir veri yapısıdır, ama birçok problemde kullanırız. Öğrenilmeli ki kullanılabilsin.”

Ayrık Kümeler

İki işlem ve birleşimin iki biçimi

1 · Ayrık küme birleşimi

S_i ∪ S_j = {x : x ∈ S_i ∨ x ∈ S_j}. Birleşme sonrası kümeler bağımsız olarak bulunmaz: S₁ ∪ S₂ = {0, 6, 7, 8, 1, 4, 9}.

2 · Küme_bul(i)

i öğesini içeren kümeyi bulur (kümenin adı = ağacın kökü).

Kökler 0, 4, 2. Birleşim için köklerden birinin ata bilgisi diğer kökü gösterecek şekilde günlenir.

S₁ ∪ S₂: 4'ün atası 0 yapılır; S₂ ağacı 0'ın alt ağacı olur.

S₂ ∪ S₁: bu kez 0'ın atası 4 yapılır. İkisi de doğrudur; hangisinin seçileceği maliyeti etkiler.

Ayrık Kümeler

Kümenin adı: kök düğüm

Küme adı	bağ (kök)
S₁	→ 0
S₂	→ 4
S₃	→ 2

Adlar metin olarak gerekiyorsa ayrı bir tabloda kökü gösteren bir bağ tutulur.

Birleşim ve Küme_bul algoritmalarını incelerken her küme adını ağacın kökü ile ilişkilendireceğiz: “S₁ kümesi” yerine “0 nolu küme” diyeceğiz.

Böylece Küme_bul(8) == Küme_bul(6) sorusu “8 ile 6 aynı kümede mi?” demektir.

Hocadan“Önce problemi bir matematikçi gibi, programlama bilmeyen birisi gibi ele alıyoruz; öncelikle problemi çizge teorisindeki terminoloji ile doğru ifade edebilmeliyiz.”

Dizi ile Gerçekleme

Nasıl gerçekleyelim?

Yöntem	Birleşim	Küme bul	Sorun
Bağlı liste	O(1)	O(n)	arama yavaş
Sıralı tutmak	—	—	sıralamak O(n lg n)
ata dizisi (ağaç)	O(1)	ağaç derinliği	derinliği küçük tutmalı

Hocadan“En güvenilir, en sağlam, en hızlı veri yapısı olan diziyi kullanarak gerçeklemenin bir yolu var mı?”

Düğümler 0'dan n−1'e numaralı olduğundan numarayı indis olarak kullanırız: her düğüm yalnızca bir alana (atasına) gereksinim duyar.

Dizi ile Gerçekleme

`ata` dizisi: her indis atasına bir bağ

1 ve 9'un atası 4; 3 ve 5'in atası 2; 6, 7 ve 8'in atası 0.
0, 2 ve 4 kümelerin kökleridir: ata[kök] = −1 (negatif = kök).

#define N 10
int ata[N] = { -1, 4, -1, 2, -1, 2, 0, 0, 0, 4 };

Dizi ile Gerçekleme

İlk sürüm: `Kume_Bul_1` ve `Birlesim_1`

int Kume_Bul_1(int i) {
  for (; ata[i] >= 0; i = ata[i])
    ;                /* negatife dek ilerle */
  return i;
}
void Birlesim_1(int i, int j) {
  ata[i] = j;        /* i kümesini j'ye bağla */
}

Küme_bul(i)

Ata bilgisi negatif bir değer olana (köke) dek ilerler; kökü döndürür.

Birleşim(i, j)

i ve j kümeleri (kökleri) aktarıldıktan sonra biri diğerinin alt ağacı olacak şekilde günlenir: O(1).

Ön koşul

i ve j kök olmalıdır; değilse önce Kume_Bul_1 ile kökler bulunur.

Dizi ile gerçekleme · kodu adım adım çalıştır

Kod izleme: `Kume_Bul_1(9)`, `Birlesim_1(4, 0)`

Kume_Bul_1(9): 9 hangi kümede?

ata[9] = 4 ≥ 0 → i = ata[i] = 4.

ata[4] = −1 < 0: kök. return 4 → 9, 4 nolu kümede.

Birlesim_1(4, 0): iki kök veriliyor.

ata[4] = 0: 4'ün ağacı 0'ın altına girdi. Tek atama: O(1).

Yeniden Kume_Bul_1(9): yol bir düğüm uzadı.

ata[9] = 4 ≥ 0 → i = 4.

ata[4] = 0 ≥ 0 → i = 0.

return 0: artık 9, 0 nolu kümede. Maliyet = düğümün derinliği.

int Kume_Bul_1(int i) {
  for (; ata[i] >= 0; i = ata[i])
    ;                /* negatife dek ilerle */
  return i;
}
void Birlesim_1(int i, int j) {
  ata[i] = j;        /* i kümesini j'ye bağla */
}

Analiz · kodu adım adım çalıştır

Kod izleme: `Birlesim_1(0,1)` … `Birlesim_1(3,4)`, `Kume_Bul_1(0)`

n = 5 tek öğeli küme: S_i = {i}, tümünde ata[i] = −1.

Birlesim_1(0, 1): ata[0] = 1. Her çağrı O(1).

Birlesim_1(1, 2): ata[1] = 2. Her çağrı O(1).

Birlesim_1(2, 3): ata[2] = 3. Her çağrı O(1).

Birlesim_1(3, 4): ata[3] = 4. Her çağrı O(1).

Ağaç bir zincire dönüştü; derinlik n. Şimdi Kume_Bul_1(0).

i = ata[0] = 1 (1. ilerleme).

i = ata[1] = 2 (2. ilerleme).

i = ata[2] = 3 (3. ilerleme).

i = ata[3] = 4 (4. ilerleme).

return 4 — 4 = n−1 ilerleme. Kume_Bul_1(1), (2)… sırayla n−2, n−3, … ilerler: toplam Σ = O(n²).

int Kume_Bul_1(int i) {
  for (; ata[i] >= 0; i = ata[i])
    ;                /* negatife dek ilerle */
  return i;
}
void Birlesim_1(int i, int j) {
  ata[i] = j;        /* i kümesini j'ye bağla */
}

Analiz

`Kume_Bul_1` ve `Birlesim_1`'in analizi

/* n tek öğeli kümeyle başla */
Birlesim_1(0, 1);
Birlesim_1(1, 2);
...
Birlesim_1(n-2, n-1);
Kume_Bul_1(0);
Kume_Bul_1(1);
...
Kume_Bul_1(n-1);

n−1 birleşim: her biri sabit → toplam O(n), sorun yok.
Ağaç zincire döner; derinlik n olur.
(n−i). düzeydeki i için Kume_Bul_1 O(i) sürer: 0 için n−1, 1 için n−2… ilerleme.
Tek bir Kume_Bul_1 O(n)'e, n tanesi toplamda Σ i = O(n²)'ye çıkar.

Bu işlem dizisi ağaç yapısını bozar. Suçlu birleşimin kendisi değil, hangi ağacın hangisine bağlandığıdır. Çözüm: ağırlıklı kural.

Analiz

Bir parantez: en kötü durumu test etmek

En kötü durum girdisi

Worst case analizinde kod, çakılacağı ya da işletiminin en uzun süreceği verilerle test edilmelidir. Bunu saptamak zordur.

Burada

Zincir üreten birleşim sırası, Kume_Bul_1 için tam da böyle bir girdidir: rastgele testler onu kolayca kaçırır.

Hocadan“Beta sürümü ne demektir? ‘Biz kafasızız, gözden kaçırdığımız hatalar olabilir. Kafasızlığımızı affedin, hata bulursanız bizi bilgilendirin ki, onun üstüne gidelim.’ Software Testing ayrı bir alandır; onun üzerine de makaleler okunmalı.”

Ağırlıklı Kural

Ağırlıklı kural (weighting rule)

Tanım: i ağacındaki düğüm sayısı j ağacındakinden azsa j, i'nin atası; aksi hâlde i, j'nin atası yapılır. (Düğüm sayısı çok olan ata olur.)

Hocadan“Sual: Acaba her kümede (ağaçta) kaç düğüm olduğu bilgisi için ayrı bir dizi mi tutmamız gerekir? El-Cevap: Kökler dışındaki tüm düğümler için ata dizisinde pozitif değerler tutuluyordu. Öyleyse köklere ilişkin düğüm sayısı bilgisi de ata dizisinde negatif olarak tutulabilir.”

Ağırlıklı Kural

`Birlesim_2`: kökte eksi düğüm sayısı

void Birlesim_2(int i, int j) {
  /* ağırlıklı kural; i ve j kök olmalı */
  int p = ata[i] + ata[j];  /* -(toplam düğüm) */
  if (ata[i] > ata[j]) {    /* i'de daha az düğüm */
    ata[i] = j;             /* i'yi j'ye bağla */
    ata[j] = p;             /* j'nin sayısını günle */
  } else {                  /* j'de az ya da eşit */
    ata[j] = i;
    ata[i] = p;
  }
}

Kökte −sayı

Kökteki değer −(düğüm sayısı): tek öğeli küme −1, 8 öğeli küme −8.

Neden >?

Değerler negatif: ata[i] > ata[j], i'nin daha az düğümü olduğu anlamına gelir (−2 > −4).

Maliyet

Hâlâ O(1); ek dizi gerekmez.

Ağırlıklı kural · kodu adım adım çalıştır

Kod izleme: `Birlesim_2` (0,1) (2,3) (4,5) (6,7)

Birlesim_2(0, 1): 0 kümesinde 1, 1 kümesinde 1 düğüm.

p = -1 + (-1) = -2: birleşik kümede 2 düğüm.

-1 > -1 yanlış (j'de az ya da eşit) → else: j, i'ye bağlanacak.

ata[1] = 0, ata[0] = -2. En derin düğüm 2. düzeyde.

Birlesim_2(2, 3): 2 kümesinde 1, 3 kümesinde 1 düğüm.

p = -1 + (-1) = -2: birleşik kümede 2 düğüm.

-1 > -1 yanlış (j'de az ya da eşit) → else: j, i'ye bağlanacak.

ata[3] = 2, ata[2] = -2. En derin düğüm 2. düzeyde.

Birlesim_2(4, 5): 4 kümesinde 1, 5 kümesinde 1 düğüm.

p = -1 + (-1) = -2: birleşik kümede 2 düğüm.

-1 > -1 yanlış (j'de az ya da eşit) → else: j, i'ye bağlanacak.

ata[5] = 4, ata[4] = -2. En derin düğüm 2. düzeyde.

Birlesim_2(6, 7): 6 kümesinde 1, 7 kümesinde 1 düğüm.

p = -1 + (-1) = -2: birleşik kümede 2 düğüm.

-1 > -1 yanlış (j'de az ya da eşit) → else: j, i'ye bağlanacak.

ata[7] = 6, ata[6] = -2. En derin düğüm 2. düzeyde.

void Birlesim_2(int i, int j) {
  /* ağırlıklı kural; i ve j kök olmalı */
  int p = ata[i] + ata[j];  /* -(toplam düğüm) */
  if (ata[i] > ata[j]) {    /* i'de daha az düğüm */
    ata[i] = j;             /* i'yi j'ye bağla */
    ata[j] = p;             /* j'nin sayısını günle */
  } else {                  /* j'de az ya da eşit */
    ata[j] = i;
    ata[i] = p;
  }
}

Ağırlıklı kural · kodu adım adım çalıştır

Kod izleme: `Birlesim_2` (0,2) (4,6) (0,4)

Birlesim_2(0, 2): 0 kümesinde 2, 2 kümesinde 2 düğüm.

p = -2 + (-2) = -4: birleşik kümede 4 düğüm.

-2 > -2 yanlış (j'de az ya da eşit) → else: j, i'ye bağlanacak.

ata[2] = 0, ata[0] = -4. En derin düğüm 3. düzeyde.

Birlesim_2(4, 6): 4 kümesinde 2, 6 kümesinde 2 düğüm.

p = -2 + (-2) = -4: birleşik kümede 4 düğüm.

-2 > -2 yanlış (j'de az ya da eşit) → else: j, i'ye bağlanacak.

ata[6] = 4, ata[4] = -4. En derin düğüm 3. düzeyde.

Birlesim_2(0, 4): 0 kümesinde 4, 4 kümesinde 4 düğüm.

p = -4 + (-4) = -8: birleşik kümede 8 düğüm.

-4 > -4 yanlış (j'de az ya da eşit) → else: j, i'ye bağlanacak.

ata[4] = 0, ata[0] = -8. En derin düğüm 4. düzeyde.

void Birlesim_2(int i, int j) {
  /* ağırlıklı kural; i ve j kök olmalı */
  int p = ata[i] + ata[j];  /* -(toplam düğüm) */
  if (ata[i] > ata[j]) {    /* i'de daha az düğüm */
    ata[i] = j;             /* i'yi j'ye bağla */
    ata[j] = p;             /* j'nin sayısını günle */
  } else {                  /* j'de az ya da eşit */
    ata[j] = i;
    ata[i] = p;
  }
}

Ağırlıklı Kural

Soru: Ağacı ne kadar dejenere eder, bozar?

Hocadan“Algoritma doğru, etkili ve yazılım mühendisliği kurallarına göre yazılacak. Ama bitmiyor, en çok bozacak veriyi sorguluyoruz. Arka planda ne olursa, kodum en fazla çalışır? Bilgisayar bilimi, bilgisayar mühendisliği işte budur!”

Hocadan“‘Hepiniz C, Java vs. biliyor musunuz?’ Evet, biliyorlar. ‘Tamam, hepiniz işe girin, aynı maaş!’ Bilgisayar mühendisi der ki: ‘Bir dakika! Ben bilgisayar mühendisiyim. Nasıl aynı maaş olur? Sen bir soru sor bakalım! Bir soru sor, nasıl çözdüğüme bak!’”

Ağırlıklı kuralda en kötü durum: her seferinde eşit büyüklükte iki ağacı birleştirmek (Birlesim_2 izlemelerindeki gibi). Her birleşimde küçük ağacın tüm düğümlerinin derinliği 1 artar, ama ağaç en az iki katına çıkar.

Ağırlıklı Kural

Lemma: ağırlıklı birleşimle derinlik logaritmiktir

Lemma (Horowitz)T, Birlesim_2 ile çeşitli kümelerin birleşimi sonucu elde edilmiş m düğümlü bir ağaç ise T'nin derinliği (düzey sayısı) ⌊lg m⌋ + 1'den büyük olamaz.

İspat fikri (tümevarım): bir düğümün derinliği yalnızca onun ağacı daha küçük ya da eşit bir ağaca bağlanınca 1 artar.
O zaman düğümün yer aldığı ağaç en az iki katına çıkar.
m düğüme en çok lg m kez iki katına çıkılabilir → derinlik ≤ ⌊lg m⌋ + 1.

Hocadan“Matematik bölümü olsaydık ‘İspatlayınız.’ diye soru devam edecekti. […] Karmaşıklığı n'den ⌊lg n⌋+1'e düşürdük. Algoritma geliştirme bu, işte! Ama yerimizde durmuyoruz, devam…”

Azaltma Kuralı

Azaltma kuralı (collapsing rule)

Son durumdaki yapıda Küme_bul(7) köke 3 ilerlemede ulaşır. Program Küme_bul(7)'yi tekrar tekrar işletirse maliyet katlanır. Düğüm sayısı az olanı çok olana eklesek bile derinlik artabiliyor; derinliği denetleyemediğimize göre bir adım ileri gideriz:

TanımEğer j, i düğümünden köke olan yol üzerinde bir düğüm ise (i kök değil) j düğümü doğrudan köke bağlanır.

Hocadan“Bunun graf teorisindeki karşılığı ‘kaplama’ ya da ‘kapama’. Graf teorisi ödevlerinden birinde, hangisi olduğu söylenmeyecek, bu kullanılmalı. Problem farklı, alt yapısı bu.”

Azaltma Kuralı

`Kume_bul_2`: önce kök bulunur, sonra yol köke bağlanır

int Kume_bul_2(int i) {
  int r, s;
  for (r = i; ata[r] >= 0; r = ata[r])
    ;                   /* kökü bul */
  while (i != r) {      /* yolu azalt */
    s = ata[i];         /* i'nin atasını sakla */
    ata[i] = r;         /* i'yi doğrudan köke bağla */
    i = s;              /* atasına geç */
  }
  return r;
}

1. geçiş (for)

r kökü bulur (ata bilgisi negatif).

2. geçiş (while)

Yol üzerindeki her düğüm doğrudan r'ye bağlanır. Köke zaten bağlı bir düğüm için de (gereksiz ama zararsız) bir kez çalışır.

Kazanç

Aynı yoldaki sonraki aramalar bir çırpıda köke ulaşır.

Azaltma kuralı · kodu adım adım çalıştır

Kod izleme: `Kume_bul_2(7)`

Kume_bul_2(7).

ata[7] = 6 ≥ 0 → r = 6.

ata[6] = 4 ≥ 0 → r = 4.

ata[4] = 0 ≥ 0 → r = 0.

ata[0] = -8 < 0: kök r = 0.

i = 7 ≠ r: s = ata[7] = 6 saklanır.

ata[7] = 0: 7 doğrudan köke bağlandı; i = s = 6.

i = 6 ≠ r: s = ata[6] = 4 saklanır.

ata[6] = 0: 6 doğrudan köke bağlandı; i = s = 4.

i = 4 ≠ r: s = ata[4] = 0 saklanır.

ata[4] = 0 (zaten köke bağlıydı: fazladan bir tur); i = 0.

i == r: döngü biter, return 0. ata = [-8, 0, 0, 2, 0, 4, 0, 0].

int Kume_bul_2(int i) {
  int r, s;
  for (r = i; ata[r] >= 0; r = ata[r])
    ;                   /* kökü bul */
  while (i != r) {      /* yolu azalt */
    s = ata[i];         /* i'nin atasını sakla */
    ata[i] = r;         /* i'yi doğrudan köke bağla */
    i = s;              /* atasına geç */
  }
  return r;
}

Azaltma kuralı · kodu adım adım çalıştır

Kod izleme: yine `Kume_bul_2(7)`, sonra `Kume_bul_2(5)`

Kume_bul_2(7).

ata[7] = 0 ≥ 0 → r = 0.

ata[0] = -8 < 0: kök r = 0.

i = 7 ≠ r: s = ata[7] = 0 saklanır.

ata[7] = 0 (zaten köke bağlıydı: fazladan bir tur); i = 0.

i == r: döngü biter, return 0. ata = [-8, 0, 0, 2, 0, 4, 0, 0].

Kume_bul_2(5).

ata[5] = 4 ≥ 0 → r = 4.

ata[4] = 0 ≥ 0 → r = 0.

ata[0] = -8 < 0: kök r = 0.

i = 5 ≠ r: s = ata[5] = 4 saklanır.

ata[5] = 0: 5 doğrudan köke bağlandı; i = s = 4.

i = 4 ≠ r: s = ata[4] = 0 saklanır.

ata[4] = 0 (zaten köke bağlıydı: fazladan bir tur); i = 0.

i == r: döngü biter, return 0. ata = [-8, 0, 0, 2, 0, 0, 0, 0].

int Kume_bul_2(int i) {
  int r, s;
  for (r = i; ata[r] >= 0; r = ata[r])
    ;                   /* kökü bul */
  while (i != r) {      /* yolu azalt */
    s = ata[i];         /* i'nin atasını sakla */
    ata[i] = r;         /* i'yi doğrudan köke bağla */
    i = s;              /* atasına geç */
  }
  return r;
}

Azaltma Kuralı

“For vardı, bir de while ekledik!”

Hocadan“‘For vardı, bir de while döngüsü ekledik. Bu nasıl iyileştirme, anlamadım!’ Ben de anlamadım, bakalım. Küme_bul_2(7) ikinci kez çağrılınca ve sonraki çağrılarda bir çırpıda r=0 bulacaktır.”

Çağrı	Kume_Bul_1 (ilerleme)	Kume_bul_2 (ilerleme + bağlama)
1. Küme_bul(7)	3	3 + 3
2. Küme_bul(7)	3	1 + 1
10 kez Küme_bul(7)	30	6 + 9·2 = 24
Küme_bul(5) (sonra)	2	2 + 2, ardından 1

İlk çağrı yaklaşık iki kat pahalıdır, ama yolu kalıcı olarak kısaltır. Maliyet, birçok işlem üzerinden amortize edilince neredeyse sabite iner.

Azaltma Kuralı

Lemma (Tarjan ve van Leeuwen): neredeyse sabit

LemmaHer biri tek düğümlü kümelerle başlanıp f küme bulma ve u birleştirme (ağırlıklı kural + azaltma kuralı) herhangi bir karışık sırada uygulandığında gereken en çok zaman T(f, u) olsun. u ≥ n/2 için:

k₁·(n + f·α(f+n, n)) ≤ T(f, u) ≤ k₂·(n + f·α(f+n, n))

α: ters Ackermann fonksiyonu; çok yavaş artar.
Evrendeki atom sayısı kadar öğe için bile uygulamada α ≤ 4.
İşlem başına maliyet n'e bölünce neredeyse O(1).

/* Ackermann: çok hızlı büyür */
A(m, n) = n + 1                  m = 0
        = A(m-1, 1)              m > 0, n = 0
        = A(m-1, A(m, n-1))      m > 0, n > 0

Hocadan“1 milyon öğe var; biri O(1)'de buluyor, öteki hâlâ listede arıyor… Hani dedik ya, aynı işe girecek olan matematikçi ile mühendisin farkı budur işte!”

Azaltma Kuralı

Ackermann fonksiyonu ve tersi

	n = 0	n = 1	n = 2	n = 3	n = 4
m = 0	1	2	3	4	5
m = 1	2	3	4	5	6
m = 2	3	5	7	9	11
m = 3	5	13	29	61	125
m = 4	13	65533	2⁶⁵⁵³⁶−3	…	…

A(5, 1) = 2^{2^…²} − 3 (65536 tane 2'nin üs kulesi): akıl almaz büyüklük.
Ters: α(m, n) = min{ i ≥ 1 : A(i, ⌊m/n⌋) ≥ lg n } — A çok hızlı büyüdüğü için α çok yavaş büyür.

Ackermann fonksiyonunun birden çok tanımı vardır. Yukarıdaki tanımla A(3,4) = 125'tir; Horowitz'in kullandığı tanımda (A(1,j) = 2^j …) ise A(3,1) = 16'dır. Hangi tanım seçilirse seçilsin sonuç değişmez: uygulamada α ≤ 4.

Azaltma Kuralı

Sınav sorusu: Ackermann fonksiyonunu özyinelemeli yazınız

Sınav sorusuAckermann fonksiyonunu özyinelemeli olarak yazınız. Ardından A(1, 2) çağrısının çağrı yığınını adım adım gösteriniz.

Çözüm

unsigned long ackermann(unsigned long m,
                        unsigned long n) {
  if (m == 0) return n + 1;
  if (n == 0) return ackermann(m - 1, 1);
  return ackermann(m - 1, ackermann(m, n - 1));
}

A(1,2) = A(0, A(1,1)) = A(0, A(0, A(1,0))) = A(0, A(0, A(0,1))) = A(0, A(0, 2)) = A(0, 3) = 4. A(4, 2) bile hiçbir bilgisayarda bitmez; yığın taşar.

Özyineleme · kodu adım adım çalıştır

Kod izleme: `ackermann(1, 2)`

ackermann(1, 2) çağrılır.

A(1,2): önce içteki A(1,1) hesaplanmalı.

A(1,1): önce içteki A(1,0) hesaplanmalı.

A(1,0): n = 0 → A(0, 1) çağrılır.

A(0,1): m = 0 → return 2.

A(1,0) = A(0,1) = 2, dönülür.

İç çağrı 2 verdi → dış çağrı A(0,2).

A(0,2): m = 0 → return 3.

A(1,1) = 3.

İç çağrı 3 verdi → dış çağrı A(0,3).

A(0,3): m = 0 → return 4.

A(1,2) = 4.

unsigned long ackermann(unsigned long m,
                        unsigned long n) {
  if (m == 0) return n + 1;
  if (n == 0) return ackermann(m - 1, 1);
  return ackermann(m - 1, ackermann(m, n - 1));
}

Azaltma Kuralı

Bir parantez: bu lemmalar nereden geliyor?

Hocadan“Tarjan ünlü bir graf teoricidir, birçok teorisi var. Bu lemma, Tarjan ile Jan van Leeuwen’in ortak çalışmasından çıktı (1984).”

Hocadan“Lisansta 4 yıl okunup bir meslek kazanılıyor, doktorada ise yalnızca bir problem üzerine 4 yıl çalışılıyor. Dünyada çözülememiş bir problem çözülüyor […] O yüzden grup içinde çalışılırsa sürekli öğrenilir.”

Hocadan“Bu konular bir haftada bitmez; hiç çalışılmazsa hiç bitmez. Her gün düzenli olarak 2–3 saat çalışmak gerekir. Haftanın konusu hemen o hafta tekrar edilmeli.”

Uygulama · kodu adım adım çalıştır

Kod izleme: bağlantılı bileşen sayma

Kenarlar u–v: (0,1), (2,3), (1,4), (3,2). Kaç bağlantılı bileşen var?

Her düğüm kendi kümesi: ata = −1, sayi = 6.

Kenar (0, 1): Kume_bul_2(0) = 0, Kume_bul_2(1) = 1.

0 ≠ 1: farklı bileşenler → Birlesim_2(0, 1), sayi = 5.

Kenar (2, 3): Kume_bul_2(2) = 2, Kume_bul_2(3) = 3.

2 ≠ 3: farklı bileşenler → Birlesim_2(2, 3), sayi = 4.

Kenar (1, 4): Kume_bul_2(1) = 0, Kume_bul_2(4) = 4.

0 ≠ 4: farklı bileşenler → Birlesim_2(0, 4), sayi = 3.

Kenar (3, 2): Kume_bul_2(3) = 2, Kume_bul_2(2) = 2.

a == b = 2: 3 ile 2 zaten aynı bileşende; kenar bir döngü kapatır, sayı değişmez.

return 3: bileşenler {0,1,4}, {2,3}, {5}. Toplam O(n + m·α).

int bilesen_say(int n, int m, int u[], int v[]) {
  for (int i = 0; i < n; i++) ata[i] = -1;
  int sayi = n;               /* her düğüm ayrı */
  for (int e = 0; e < m; e++) {
    int a = Kume_bul_2(u[e]), b = Kume_bul_2(v[e]);
    if (a != b) {             /* farklı bileşen */
      Birlesim_2(a, b);
      sayi--;
    }
  }
  return sayi;
}

Uygulamalar

Union-find başka nerelerde?

Eşdeğerlik sınıfları

i ≡ j bildirimlerinden sınıfları çıkarmak (Horowitz'in eşdeğerlik problemi).

Ağ bağlantısı

“Bu iki bilgisayar bağlı mı?” sorularını çevrimiçi yanıtlamak (Sedgewick'in açılış örneği).

Görüntü işleme

Aynı renkteki komşu pikselleri bölgelere ayırmak (bağlantılı bileşen etiketleme).

Süzülme (percolation)

Izgarada üstten alta açık yol var mı? Monte Carlo deneylerinin çekirdeği.

Derleyiciler

Tip çıkarımında birleştirme (unification), takma ad (alias) analizi.

Çevrimdışı LCA

Tarjan'ın en yakın ortak ata algoritması.

Kruskal algoritması: kenarlar ağırlığa göre sıralanır; bir kenarın uçları için Küme_bul farklı kökler verirse kenar ağaca alınır ve iki küme birleştirilir, aynı kökü verirse kenar bir döngü kapatır ve reddedilir. Maliyet: sıralama O(m lg m) + union-find ≈ O(m·α).

Özet

Sınav sorusu: ata dizisinin içeriği

Sınav sorusuBirlesim_2 ve Kume_bul_2 verilmiştir; kümeler S₁ = {0, 6, 7, 8}, S₂ = {1, 4, 9}, S₃ = {2, 3, 5} (şekildeki ağaçlar).
(i) İlk başta ata dizisinin içeriği nedir?
(ii) Birlesim_2(4, 2); Kume_bul_2(5); Birlesim_2(0, 4); Kume_bul_2(7); Kume_bul_2(3); çağrılarından sonra ata ne olur? Not: (i) hatalıysa (ii) değerlendirilmez.

Çözüm

ata = [-4, 4, -3, 2, -3, 2, 0, 0, 0, 4] — köklerde eksi düğüm sayısı (−4, −3, −3).
Birlesim_2(4,2): eşit (−3, −3) → 2, 4'e bağlanır, ata[4] = −6. Kume_bul_2(5): 5 → 2 → 4, 5 doğrudan 4'e bağlanır. Birlesim_2(0,4): −4 > −6 → 0, 4'e bağlanır, ata[4] = −10. Kume_bul_2(7): 7 → 0 → 4, 7 köke bağlanır. Kume_bul_2(3): 3 → 2 → 4, 3 köke bağlanır. Sonuç: [4, 4, 4, 4, -10, 4, 0, 4, 0, 4].

Özet

Karmaşıklık özeti

Sürüm	Birleşim	Küme bul (en kötü)	n−1 birleşim + m bulma
Birlesim_1 + Kume_Bul_1	O(1)	O(n)	O(n + m·n)
Birlesim_2 (ağırlıklı)	O(1)	O(lg n)	O(n + m lg n)
Birlesim_2 + Kume_bul_2	O(1)	O(lg n) tek işlem	O(n + m·α(m+n, n))

Bellek: yalnızca n tamsayılık ata dizisi. α ≤ 4 olduğundan son satır uygulamada doğrusaldır.

Birleşim tek başına hep O(1)'dir; maliyeti belirleyen, ağacın derinliği yani Küme_bul'dur. Ağırlıklı kural derinliği sınırlar, azaltma kuralı yolları kısaltır.

Özet

Sık yapılan hatalar

1Birleşime kök yerine rastgele düğüm vermek: ata[i] = j i'nin alt ağacını koparır.

2Aynı kümedeki iki kökü birleştirmek (i == j): kök kendini gösterir, sonsuz döngü.

3Ağırlıklı kuralda negatif değerlerin karşılaştırmasını ters yorumlamak (−2 > −4 “daha az düğüm”).

4Birleşimde kökteki düğüm sayısını (p) günlemeyi unutmak.

5Kume_bul_2'de atayı saklamadan (s) bağlamak: yol kaybolur.

6Başlangıçta ata dizisini −1 ile doldurmamak.

Özet

Alıştırmalar

n = 6, ata tümüyle −1. Birlesim_2(0,1); Birlesim_2(2,3); Birlesim_2(0,2); Birlesim_2(4,5) sonrası ata?
Ağırlıklı kural kullanılırken 16 düğümlü bir ağacın derinliği en çok kaçtır?
Ağırlık yerine yükseklik (rank) tutan bir birleşim kuralı yazın. Ne değişir?
Kume_bul_2'yi özyinelemeli yazın (tek satırlık yol sıkıştırma).
Kruskal'da bir kenarın reddedilmesi neden döngü demektir?
n düğüm, m kenarlı bir çizgede bileşen sayısını bulmanın maliyeti nedir?

Cevapları göster

[-4, 0, 0, 2, -2, 4] (0 kökünde 4 düğüm; 4 kökünde 2).
⌊lg 16⌋ + 1 = 5 düzey.
Kökte −(yükseklik) tutulur; eşitse biri bağlanır ve yükseklik 1 artar. Derinlik yine O(lg n); azaltma ile rank üst sınır olur.
int bul(int i) { return ata[i] < 0 ? i : (ata[i] = bul(ata[i])); }
Uçlar zaten aynı kümede, yani aralarında seçilmiş kenarlardan oluşan bir yol var; kenar yolu döngüye kapatır.
O(n + m·α(m+n, n)) — pratikte doğrusal.

Özet

Bölüm özeti

Model

Ayrık kümeler = kökü küme adı olan, çocuktan ataya bağlı ağaçlar.

Gösterim

Tek ata dizisi; kökte negatif değer.

Kötü durum

Rastgele bağlama zincir üretir: n bulma O(n²).

Ağırlıklı kural

Küçük ağaç büyüğe: derinlik ≤ ⌊lg m⌋ + 1.

Azaltma kuralı

Yol köke bağlanır; sonraki aramalar bir çırpıda.

Sonuç

İkisi birlikte: işlem başına α ≤ 4 — neredeyse O(1).

Özet

Kaynaklar ve devam

E. Horowitz, S. Sahni, S. Anderson-Freed, Fundamentals of Data Structures in C, Bölüm 5.10 (Set Representation).
T. H. Cormen vd., Introduction to Algorithms (CLRS), “Data Structures for Disjoint Sets” bölümü.
R. Sedgewick, Algorithms in C, Bölüm 1 (union-find ile bağlantılılık).
R. E. Tarjan, J. van Leeuwen, “Worst-case analysis of set union algorithms”, J. ACM 31(2), 1984.

← Bölüm 15: Çizgeler Ders sayfası Bölüm 17: Minimum Kapsayan Ağaçlar →

Son

Bölüm 16: Kümeler ve Union-Find

Sonraki bölüm: Bölüm 17: Minimum Kapsayan Ağaçlar · Ders sayfası

1 / 1 C ile Veri Yapıları

Bölüm 16: Kümeler ve Union-Find

Öğrenme Çıktıları

Kümelerde birleşim (union) ve bulma (find)

İki işlem ve birleşimin iki biçimi

Kümenin adı: kök düğüm

Nasıl gerçekleyelim?

ata dizisi: her indis atasına bir bağ

İlk sürüm: Kume_Bul_1 ve Birlesim_1

Kod izleme: Kume_Bul_1(9), Birlesim_1(4, 0)

Kod izleme: Birlesim_1(0,1) … Birlesim_1(3,4), Kume_Bul_1(0)

Kume_Bul_1 ve Birlesim_1'in analizi

Bir parantez: en kötü durumu test etmek

Ağırlıklı kural (weighting rule)

Birlesim_2: kökte eksi düğüm sayısı

Kod izleme: Birlesim_2 (0,1) (2,3) (4,5) (6,7)

Kod izleme: Birlesim_2 (0,2) (4,6) (0,4)

Soru: Ağacı ne kadar dejenere eder, bozar?

Lemma: ağırlıklı birleşimle derinlik logaritmiktir

Azaltma kuralı (collapsing rule)

Kume_bul_2: önce kök bulunur, sonra yol köke bağlanır

Kod izleme: Kume_bul_2(7)

Kod izleme: yine Kume_bul_2(7), sonra Kume_bul_2(5)

“For vardı, bir de while ekledik!”

Lemma (Tarjan ve van Leeuwen): neredeyse sabit

Ackermann fonksiyonu ve tersi

Sınav sorusu: Ackermann fonksiyonunu özyinelemeli yazınız

Kod izleme: ackermann(1, 2)

Bir parantez: bu lemmalar nereden geliyor?

Kod izleme: bağlantılı bileşen sayma

Union-find başka nerelerde?

Sınav sorusu: ata dizisinin içeriği

Karmaşıklık özeti

Sık yapılan hatalar

Alıştırmalar

Bölüm özeti

Kaynaklar ve devam

Son

`ata` dizisi: her indis atasına bir bağ

İlk sürüm: `Kume_Bul_1` ve `Birlesim_1`

Kod izleme: `Kume_Bul_1(9)`, `Birlesim_1(4, 0)`

Kod izleme: `Birlesim_1(0,1)` … `Birlesim_1(3,4)`, `Kume_Bul_1(0)`

`Kume_Bul_1` ve `Birlesim_1`'in analizi

`Birlesim_2`: kökte eksi düğüm sayısı

Kod izleme: `Birlesim_2` (0,1) (2,3) (4,5) (6,7)

Kod izleme: `Birlesim_2` (0,2) (4,6) (0,4)

`Kume_bul_2`: önce kök bulunur, sonra yol köke bağlanır

Kod izleme: `Kume_bul_2(7)`

Kod izleme: yine `Kume_bul_2(7)`, sonra `Kume_bul_2(5)`

Kod izleme: `ackermann(1, 2)`