Giriş

Öğrenme Çıktıları

Küme ADT

Küme (Set)

Küme ADT

Küme İşlemleri (İşleçler)

Küme ADT

java.util.Set Arayüzü

Set<Integer> a = new HashSet<>(List.of(1,2,3,4,5));
Set<Integer> b = new HashSet<>(List.of(3,4,5,6,7));
Set<Integer> bir = new HashSet<>(a);
bir.addAll(b);     // [1..7]
Set<Integer> kes = new HashSet<>(a);
kes.retainAll(b);  // [3, 4, 5]
Set<Integer> fark = new HashSet<>(a);
fark.removeAll(b); // [1, 2]
a.containsAll(b);  // false

Küme Uygulamaları

java.util.Set Uygulamaları

for (String s : List.of("elma", "kiraz", "armut", "elma")) {
    hash.add(s);  linked.add(s);  tree.add(s);
}
// HashSet       → [armut, kiraz, elma]   (sıra hash'e bağlı, farklı olabilir)
// LinkedHashSet → [elma, kiraz, armut]   (eklenme sırası)
// TreeSet       → [armut, elma, kiraz]   (alfabetik)

Küme Uygulamaları

Hash Tabanlı Küme

Küme Uygulamaları

Ağaç Tabanlı (Sıralı) Küme

Sıralı yapının getirdiği ek işlemler (S = {5, 10, 15, 20, 25, 30, 40}):

Küme Uygulamaları

Sıralı Yapıyla Birleşim ve Kesişim

Küme sıralı dizi/liste olarak tutulursa birleşim ve kesişim, birleştirme sıralamasındaki merge adımıyla tek geçişte bulunur (Goodrich: genel birleştirme, generic merge):

Küme Uygulamaları

Küme Uygulamalarının Karşılaştırması

* ortalama durum (en kötü O(n)). † tekrar kontrolü için önce arama gerekir. Hash ile birleşim: B'nin her öğesi için contains + add.

Çoklu Küme

Çoklu Küme (Multiset / Bag)

Çoklu Küme

Java ile Çoklu Küme

class CokluKume<E> {
    private final Map<E, Integer> say = new HashMap<>();
    private int n = 0;                                   // tekrarlar dahil öğe sayısı
    void add(E e) { say.merge(e, 1, Integer::sum); n++; }  // yoksa 1, varsa +1
    int count(E e) { return say.getOrDefault(e, 0); }
    boolean remove(E e) {
        Integer c = say.get(e);
        if (c == null) return false;                     // e yok
        if (c == 1) say.remove(e);                          // sayaç 0 olacak: girdiyi sil
        else say.put(e, c - 1);
        n--;
        return true;
    }
    int size() { return n; }
}

Ayrık Kümeler (Union-Find)

Ayrık Kümeler ve Union-Find

• Ayrık kümeler (disjoint sets): hiçbir öğesi ortak olmayan kümeler topluluğu. Her öğe tam olarak bir kümeye aittir.
• Union-Find (Disjoint Set Union, DSU) bu kümeleri tutan veri yapısıdır. İki ana işlemi vardır:

Her küme bir ağaç: her düğüm atasını (parent) gösterir; kök kendini gösterir ve kümenin temsilcisidir.

Ayrık Kümeler (Union-Find)

Mıknatıs Örneği

Ayrık Kümeler (Union-Find)

Find ve Union İşlemleri

find(x):
  if x.ata != x:
    x.ata = find(x.ata)  // yol kısaltma
  return x.ata

union(x, y):
  kök1 = find(x)
  kök2 = find(y)
  if kök1 != kök2:
    // bir kümenin kökünü diğer
    // kümenin köküne ata
    kök1.ata = kök2

Ayrık Kümeler (Union-Find)

Nesneleri İndislere Eşleme

• Union-Find en verimli hâliyle dizi üzerinde çalışır: öğeler 0..n−1 tamsayılarıdır.
• Öğeler harf, şehir, kişi… ise önce her nesne bir indise rastgele (ama kalıcı) eşlenir ve bu eşleme bir hash tablosunda saklanır.
• Sonra ata[i] = i ile her öğe kendi kümesinin kökü olarak başlar (makeSet).

Map<Character, Integer> indis = new HashMap<>();   // 'E'→0, 'F'→1, …
int[] ata = new int[12];
for (int i = 0; i < 12; i++) ata[i] = i;             // 12 tekil küme

Ayrık Kümeler (Union-Find)

Union İşlemi Adım Adım

Ayrık Kümeler (Union-Find)

Neden İyileştirme Gerekir?

• find, kökten uzaklık kadar adım atar. Birleştirme sırası kötü seçilirse ağaç bir zincire dönüşür.
• Örnek: union(2,1), union(3,2), union(4,3), union(5,4) ve her seferinde eski kök yeninin altına bağlanırsa find(5) = 4 adım → en kötü O(n).

Ayrık Kümeler (Union-Find)

Boyuta Göre Birleştirme (Union by Size)

• Her kökte ağacın boyutunu (öğe sayısı) sakla.
• Birleştirirken küçük ağacın kökünü büyük ağacın köküne bağla; yeni boyut = iki boyutun toplamı.

Ayrık Kümeler (Union-Find)

Rütbeye Göre Birleştirme (Union by Rank)

MakeSet(x):
  p[x] = x
  rank[x] = 0

FindSet(x):
  if x != p[x]:
    p[x] = FindSet(p[x]) // yol kısaltma
  return p[x]

Link(x, y):   // x, y kök
  if rank[x] > rank[y]:
    p[y] = x
  else:
    p[x] = y
    if rank[x] == rank[y]:
      rank[y] = rank[y] + 1

Union(x, y):
  Link(FindSet(x), FindSet(y))

Ayrık Kümeler (Union-Find)

Yol Kısaltma (Path Compression)

Yol kısaltma (path compression): find sırasında rastlanan tüm düğümleri doğrudan köke bağla. Sonraki find'lar tek adımda biter.

Ayrık Kümeler (Union-Find)

Union-Find Karmaşıklığı

Ayrık Kümeler (Union-Find)

Java: Düğüm (Nesne) Tabanlı Union-Find

class SetDugum {
  int veri;
  int sira;   // rütbe
  SetDugum ata;

  SetDugum(int veri) {
    this.veri = veri;
    this.ata = this;
    this.sira = 0;
  }
}

SetDugum find(SetDugum d) {
  if (d != d.ata)
    d.ata = find(d.ata); // kısaltma
  return d.ata;
}

void union(SetDugum x, SetDugum y) {
  SetDugum kokX = find(x);
  SetDugum kokY = find(y);
  if (kokX == kokY) return;
  // rütbeye göre birleştirme
  if (kokX.sira < kokY.sira) {
    kokX.ata = kokY;
  } else if (kokX.sira > kokY.sira) {
    kokY.ata = kokX;
  } else { // eşit: birini seç
    kokY.ata = kokX;
    kokX.sira++;
  }
}

Ayrık Kümeler (Union-Find)

Java: Dizi Tabanlı Union-Find

class UnionFind {
  private final int[] ata, sira;
  UnionFind(int n) {
    ata = new int[n];  sira = new int[n];
    for (int i = 0; i < n; i++) ata[i] = i;
  }
  int find(int x) {
    if (ata[x] != x) ata[x] = find(ata[x]);
    return ata[x];
  }
  boolean union(int x, int y) {
    int kx = find(x), ky = find(y);
    if (kx == ky) return false;
    if (sira[kx] < sira[ky]) ata[kx] = ky;
    else if (sira[kx] > sira[ky]) ata[ky] = kx;
    else { ata[kx] = ky; sira[ky]++; }
    return true;
  }
}

Kruskal Algoritması

Minimum Kapsayan Ağaç (Minimum Spanning Tree)

Kruskal Algoritması

Kruskal Algoritması

Kruskal(G):
  T = ∅          // seçilen kenarlar
  for her düğüm v: makeSet(v)
  kenarları ağırlığa göre sırala
  for her (u, v), küçükten büyüğe:
    if find(u) != find(v): // döngü yok
      T.ekle((u, v))
      union(u, v)
    if |T| == n − 1: break
  return T

Kruskal Algoritması

Kruskal Algoritması Adım Adım

Kruskal Algoritması

İkinci Örnek: Havalimanları

Özet

Özet

* ortalama durum. Union-Find maliyeti rütbe + yol kısaltma ile amortize.

Özet

Etkileşimli Simülatörler

Bu bölümün konularını tarayıcıda deneyerek pekiştirin:

Önceki bölümlerle bağlantı: Hash Tablosu · Kırmızı-Siyah Ağaç · Çizge

Özet

Örnek Problemler

1. A = {2, 4, 6, 8}, B = {1, 2, 3, 4} için A ∪ B, A ∩ B, B − A nedir?
2. Bir sözlükteki kelimeleri alfabetik sırayla ve tekrarsız yazdırmak için hangi Set uygulamasını seçersiniz?
3. "kavak" kelimesinin harflerini çoklu kümede tutun: count('a') ve size() ne döner?
4. 0..5 için sırayla union(0,1), union(2,3), union(1,3), union(4,5) yapılıyor (rütbeye göre, eşitlikte ata[x] = y). Kaç küme kalır? find(0) nedir?
5. Kruskal örneğinde C–J kenarı neden reddedildi?

Ö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.
• Sedgewick ve Wayne, Algorithms, 4. baskı, 2011.
• Oracle, Java SE 17 Set, HashSet ve TreeSet API belgeleri.