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 ADT · Kodu adım adım çalıştır

Kod İzleme: add dönüşüyle ilk tekrar

int ilkTekrar(int[] a) {
  Set<Integer> gorulen = new HashSet<>();
  for (int x : a) {
    if (!gorulen.add(x))   // eklenemedi mi?
      return x;            // zaten vardı: tekrar
  }
  return -1;               // tekrar yok
}

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       → [elma, armut, kiraz]   (kova sırası: hash'e bağlı)
// LinkedHashSet → [elma, kiraz, armut]   (eklenme sırası)
// TreeSet       → [armut, elma, kiraz]   (alfabetik)

Küme Uygulamaları

Hash Tabanlı Küme

Küme Uygulamaları · Kodu adım adım çalıştır

Kod İzleme: add / contains (m = 7)

// alanlar: List<Integer>[] kova; n; m = 7
boolean add(int x) {          // x ≥ 0
  int i = x % m;               // kova no
  for (int y : kova[i])
    if (y == x) return false;  // zaten var
  kova[i].add(x);
  n++;
  return true;
}
boolean contains(int x) {
  int i = x % m;
  for (int y : kova[i])
    if (y == x) return true;
  return false;
}

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ı · Kodu adım adım çalıştır

Sıralı Dizilerle Birleşim ve Kesişim (iki imleç)

void birlesimKesisim(int[] a, int[] b,
    List<Integer> bir, List<Integer> kes) {
  int i = 0, j = 0;
  while (i < a.length && j < b.length) {
    if (a[i] < b[j]) bir.add(a[i++]);
    else if (a[i] > b[j]) bir.add(b[j++]);
    else {                     // ortak öğe
      bir.add(a[i]);  kes.add(a[i]);
      i++;  j++;
    }
  }
  while (i < a.length) bir.add(a[i++]);
  while (j < b.length) bir.add(b[j++]);
}

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.

Küme Uygulamaları

Bit Vektörü ile Küme (Bitset)

Bellek U bit: 10⁶ öğelik evren ≈ 122 KB. Evren büyük ama küme seyrekse (ör. 3 öğe, U = 10⁹) hash tabanlı küme seçilir.

Küme Uygulamaları · Kodu adım adım çalıştır

Kod İzleme: bit işlemleriyle küme cebri

int a = 0, b = 0;
for (int x : new int[]{1, 3, 4})
  a |= 1 << x;          // x. biti yak
for (int x : new int[]{3, 5})
  b |= 1 << x;
int bir = a | b;        // birleşim
int kes = a & b;        // kesişim
int fark = a & ~b;      // fark
boolean var3 = (a >> 3 & 1) == 1;

Ç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; }
}

Çoklu Küme · Kodu adım adım çalıştır

Kod İzleme: CokluKume sayaçları

void add(E e) {
  say.merge(e, 1, Integer::sum);  n++;
}
int count(E e) {
  return say.getOrDefault(e, 0);
}
boolean remove(E e) {
  Integer c = say.get(e);
  if (c == null) return false;
  if (c == 1) say.remove(e);
  else say.put(e, c - 1);
  n--;
  return true;
}

Çoklu Küme

Çoklu Eşleme (Multimap)

Map<String, List<String>> m = new HashMap<>();
void put(String k, String v) {   // yoksa boş liste aç
  m.computeIfAbsent(k, x -> new ArrayList<>()).add(v);
}
List<String> get(String k) {
  return m.getOrDefault(k, List.of());
}

Çoklu kümeden farkı: yalnız kaç kez değil, değerlerin kendisi tutulur. Hash ile put / get O(1)*, remove(k, v) O(1 + liste boyu).

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 ebeveynini (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.ebeveyn != x:
    x.ebeveyn = find(x.ebeveyn)  // yol kısaltma
  return x.ebeveyn

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 ebeveyn
    kök1.ebeveyn = 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 ebeveyn[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[] ebeveyn = new int[12];
for (int i = 0; i < 12; i++) ebeveyn[i] = i;             // 12 tekil küme

Ayrık Kümeler (Union-Find)

Union İşlemi Adım Adım

Ayrık Kümeler (Union-Find)

Başka Bir Fikir: Quick-Find (Hızlı Bul)

• Ağaç yerine düz dizi: id[i] = i'nin küme adı; aynı kümedekilerin id'si aynı. find(p) = id[p] → O(1).
• union(p, q): id'si id[p] olan herkesi id[q] yap → tüm dizi taranır, O(n).

union(0,1), union(2,3) sonrası: 4 küme (aynı renk = aynı küme)

Ayrık Kümeler (Union-Find) · Kodu adım adım çalıştır

Kod İzleme: Quick-Find union

int find(int p) { return id[p]; }  // O(1)
void union(int p, int q) {
  int pid = id[p], qid = id[q];
  if (pid == qid) return;
  for (int i = 0; i < id.length; i++)
    if (id[i] == pid)
      id[i] = qid;           // O(n) tarama
}

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 → 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):
  ebeveyn[x] = x
  sira[x] = 0

find(x):   // yol kısaltmalı
  if x != ebeveyn[x]:
    ebeveyn[x] = find(ebeveyn[x])
  return ebeveyn[x]

link(x, y):   // x, y kök
  if sira[x] > sira[y]:
    ebeveyn[y] = x
  else:
    ebeveyn[x] = y
    if sira[x] == sira[y]:
      sira[y] = sira[y] + 1

union(x, y):
  link(find(x), find(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 ebeveyn;

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

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

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.ebeveyn = kokY;
  } else if (kokX.sira > kokY.sira) {
    kokY.ebeveyn = kokX;
  } else { // eşit: birini seç
    kokX.ebeveyn = kokY;
    kokY.sira++;
  }
}

Ayrık Kümeler (Union-Find)

Java: Dizi Tabanlı Union-Find

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

Ayrık Kümeler (Union-Find) · Kodu adım adım çalıştır

Kod İzleme: find + union

int find(int x) {
  if (ebeveyn[x] != x) ebeveyn[x] = find(ebeveyn[x]);
  return ebeveyn[x];
}
boolean union(int x, int y) {
  int kx = find(x), ky = find(y);
  if (kx == ky) return false;
  if (sira[kx] < sira[ky]) ebeveyn[kx] = ky;
  else if (sira[kx] > sira[ky]) ebeveyn[ky] = kx;
  else { ebeveyn[kx] = ky; sira[ky]++; }
  return true;
}