Bölüm 11: Çizgeler
Giriş
Öğrenme Çıktıları
Düğüm, kenar, yön, ağırlık, yol ve bağlılık kavramlarını açıklamak.
Komşuluk matrisi ile komşuluk listesini maliyetleriyle karşılaştırmak.
BFS ve DFS algoritmalarını uygulayıp sonuçlarını yorumlamak.
Ağırlıksız BFS ve Dijkstra algoritması için uygun problem türünü seçmek.
Temel Kavramlar
Çizge (Graph)
- Düğümlerin (vertex / node) ve bu düğümleri birbirine bağlayan kenarların (edge) bir araya gelmesiyle oluşur.
- Karmaşık ilişkileri, ağları ve yapıları temsil etmek için kullanılır.
- Çizge teorisi, düğümler ve kenarlar arasındaki ilişkileri inceler.
Örnek: V = {0, 1, 2, 3, 4}, E = {(0,1), (0,4), (1,2), (1,3), (1,4), (2,3), (3,4)} · n = |V| = 5, m = |E| = 7
Temel Kavramlar
Düğüm (Vertex, Node)
- Çizgenin temel yapı taşıdır.
- Şehirler, kişiler, bilgisayarlar gibi nesneleri temsil eder.
- Düğüm, bir değer (etiket, ad, konum…) saklayabilir.
- Örnek: haritadaki şehirler ve kavşaklar.

Karayolu haritası: şehirler düğüm, yollar kenar
Temel Kavramlar
Kenar (Edge)
- Düğümleri birbirine bağlayan bağlantılardır.
- Kenarlar düğümler arasındaki ilişkiyi temsil eder.
- (v, w) bir kenar ise v ve w bitişik (komşu, adjacent) düğümlerdir; kenar bu iki düğüme bağlıdır (incident).
- Örnek: şehirler arasındaki yollar, bilgisayar ağındaki bağlantılar, sosyal ağdaki arkadaşlıklar.

Bir sosyal ağ: kişiler düğüm, ilişkiler kenar
Temel Kavramlar
Derece (Degree)
- Bir düğümün derecesi, ona bağlı kenar sayısıdır:
deg(v). - Derecesi 0 olan (yalnız, isolated) düğümler de olabilir.
- Öz döngü (self-loop) dereceye 2 katkı yapar.
- Örnek: bir kavşaktaki yolların sayısı.
Her düğümün içinde kendi derecesi yazıyor
Temel Kavramlar
Yönlü Çizge (Digraph)
- Kenarlar bir düğümden diğerine belirli bir yöndedir: (u, v) ≠ (v, u).
- Geri dönüş yolu olmayabilir: örnekte B'den A'ya ulaşılamaz.
- Yönlü çizge (directed graph), kısaca digraph olarak da adlandırılır.
- Örnek: web sayfaları ve bağlantıları, ders ön koşulları, tek yönlü sokaklar.
| Düğüm | A | B | C | D | E | F |
|---|---|---|---|---|---|---|
| giriş derecesi | 0 | 2 | 1 | 1 | 1 | 1 |
| çıkış derecesi | 1 | 1 | 1 | 1 | 2 | 0 |
Temel Kavramlar
Yol (Path) ve Döngü (Cycle)
- Yol (path): ardışık düğümleri kenarlarla bağlanan düğüm dizisi.
- Basit yol: hiçbir düğümü tekrar etmeyen yol.
- Döngü (cycle): aynı düğümde başlayıp biten yol.
- Basit döngü: başlangıç düğümü dışında hiçbir düğümü tekrar etmez.
- Çizgelerde döngü olabilir; ağaçta döngü yoktur.
Yeşil: A-B-C-D-E-F-A · Kırmızı (kesikli): G-H-I-J-K-L-G
Temel Kavramlar
Örnek Çizge
- V = {1, 2, 3, 4, 5}
- E = {(1,2), (1,3), (1,4), (2,5), (3,4), (4,5)}
- Düğüm 1 ve düğüm 2 komşu.
- deg(1) = 3, deg(4) = 3, diğerleri 2 → toplam 12 = 2·6 ✓
| Dizi | Türü |
|---|---|
| 1 → 2 → 5 | basit yol |
| 1 → 3 → 4 → 1 | basit döngü |
| 1 → 3 → 4 → 1 → 2 | basit olmayan yol (1 tekrar) |
| 1 → 3 → 4 → 1 → 4 → 1 | basit olmayan döngü |
Temel Kavramlar
Bağlantılı ve Tam Çizge
- Bağlantılı (connected) çizge: her iki farklı düğüm çifti arasında bir yol vardır.
- Bağlı bileşen (connected component): birbirine yolla ulaşabilen düğümlerin en büyük grubu.
- Tam (complete) çizge: her iki farklı düğüm çifti arasında bir kenar vardır.
n düğümlü basit yönsüz çizgede m ≤ n(n−1)/2; bu üst sınıra tam çizgede ulaşılır. Bağlantılı bir çizgede m ≥ n − 1.
Temel Kavramlar
Yönlü Çizge Örneği
- V = {1, 2, 3, 4, 5}
- E = {(1,2), (1,4), (2,5), (4,5), (3,1), (4,3)}
- Düğüm 2, düğüm 1'in komşusu (1 → 2 kenarı var).
- Düğüm 1, düğüm 2'nin komşusu değil!
| Dizi | Türü |
|---|---|
| 1 → 2 → 5 | yönlü yol |
| 1 → 4 → 3 → 1 | yönlü döngü |
| 5 → … | 5'ten çıkan kenar yok |
Yönlü kenar (u, v) sıralı bir çifttir: u kuyruk (başlangıç), v baş (hedef) düğümdür.
Temel Kavramlar
Ağırlıklı Çizge
- Her kenara bir sayı (ağırlık, weight) atanır: uzaklık, süre, maliyet, kapasite…
- Bir yolun uzunluğu = üzerindeki kenar ağırlıklarının toplamı. Yönsüz veya yönlü olabilir.
Temel Kavramlar
Çizge Soyut Veri Tipi (Graph ADT)
Goodrich'teki Graph arayüzünün temel işlemleri (V: düğüm, E: kenar):
| İşlem | Açıklama |
|---|---|
numVertices(), numEdges() | Düğüm sayısı n, kenar sayısı m |
vertices(), edges() | Tüm düğümler / tüm kenarlar üzerinde gezinme |
getEdge(u, v) | u'dan v'ye kenar varsa onu, yoksa null döndürür |
endVertices(e), opposite(v, e) | Kenarın iki ucu / e kenarının v dışındaki ucu |
outDegree(v), inDegree(v) | Çıkış / giriş derecesi (yönsüzde ikisi eşit) |
outgoingEdges(v), incomingEdges(v) | v'den çıkan / v'ye gelen kenarlar |
insertVertex(x), insertEdge(u, v, x) | Yeni düğüm / yeni kenar ekler |
removeVertex(v), removeEdge(e) | Düğümü (bağlı kenarlarıyla) / kenarı siler |
Bu işlemlerin maliyeti, çizgenin bellekte nasıl temsil edildiğine bağlıdır → sonraki bölüm.
Çizge Gösterimleri
Çizge Nasıl Saklanır? Üç Temel Gösterim
Kenar listesi (edge list) en basit gösterimdir:
- Alan O(n + m); kenar eklemek O(1).
- Ama "u ile v komşu mu?" ya da "u'nun komşuları kim?" için tüm listeyi taramak gerekir: O(m).
Çizge Gösterimleri
Komşuluk Matrisi (Adjacency Matrix)
- n×n boyutunda iki boyutlu bir dizidir:
matris[i][j]= 1, düğüm i'den j'ye kenar varsa; yoksa 0. - Ağırlıklı çizgede
matris[i][j]kenarın ağırlığını tutar; kenar yoksa∞(veya özel bir değer). - Yönsüz çizgede matris simetriktir:
matris[i][j] == matris[j][i]. - Alan karmaşıklığı O(n²); düğüm sayısı arttıkça bellek hızla büyür.
Kolay
- İki düğüm arasında kenar var mı? O(1)
- Kenar ekleme / silme O(1)
Zor
- Bir düğümün komşularını bulmak: tüm satır, O(n)
- Seyrek çizgede hücrelerin çoğu boş (0)
Çizge Gösterimleri
Komşuluk Matrisi: Üç Örnek
| A | B | C | D | E | |
|---|---|---|---|---|---|
| A | 0 | 1 | 0 | 0 | 1 |
| B | 1 | 0 | 1 | 0 | 1 |
| C | 0 | 1 | 0 | 1 | 0 |
| D | 0 | 0 | 1 | 0 | 1 |
| E | 1 | 1 | 0 | 1 | 0 |
Yönsüz çizge: her kenar iki hücreye yazılır, matris köşegene göre simetrik. Satır toplamı = derece (B: 3).
| A | B | C | D | E | |
|---|---|---|---|---|---|
| A | 0 | 1 | 0 | 0 | 1 |
| B | 0 | 0 | 1 | 1 | 0 |
| C | 0 | 0 | 0 | 0 | 0 |
| D | 1 | 0 | 1 | 0 | 1 |
| E | 0 | 1 | 0 | 1 | 0 |
Yönlü çizge: satır = kaynak, sütun = hedef. Simetrik değil; satır toplamı çıkış, sütun toplamı giriş derecesi.
| A | B | C | D | E | |
|---|---|---|---|---|---|
| A | 0 | 4 | ∞ | ∞ | ∞ |
| B | ∞ | 0 | 3 | 3 | ∞ |
| C | 2 | ∞ | 0 | ∞ | 2 |
| D | ∞ | ∞ | ∞ | 0 | ∞ |
| E | ∞ | 5 | ∞ | 2 | 0 |
Ağırlıklı çizge: hücrede ağırlık, kenar yoksa ∞ (köşegende 0). Boş hücreye 0 yazmak, 0 ağırlıklı bir kenarla karıştırılabilir.
Çizge Gösterimleri
Komşuluk Listesi (Adjacency List)
- n düğüm için n adet liste (çoğunlukla bağlı liste veya dinamik dizi) tutulur.
liste[i], düğüm i'ye komşu olan düğümleri (ağırlıklıysa ağırlıklarıyla) içerir.- Yönsüz çizgede her kenar (v, w) iki listeye de eklenir: w, v'nin listesine; v, w'nin listesine.
- Alan karmaşıklığı O(n + m); seyrek çizgeler için idealdir.
Kolay
- Bir düğümün komşularını gezmek: O(deg(v))
- Kenar ekleme O(1)
Zor
- u ile v arasında kenar var mı? Listeyi taramak gerekir: O(deg(u))
Çizge Gösterimleri
Komşuluk Listesi: Üç Örnek
Yönsüz: 6 kenar → listelerde 12 kayıt (her kenar iki kez). Liste uzunluğu = derece.
Yönlü: yalnızca çıkan kenarlar listelenir; 9 kenar → 9 kayıt. C'den çıkan kenar yok, listesi boş.
Ağırlıklı: her kayıt (komşu, ağırlık) çifti tutar; ör. B'nin listesi: (C, 3), (D, 3).
Çizge Gösterimleri
Gösterimlerin Bellek ve İşlem Maliyeti
| İşlem (n düğüm, m kenar) | Kenar listesi | Komşuluk listesi | Komşuluk matrisi |
|---|---|---|---|
| Bellek | O(n + m) | O(n + m) | O(n²) |
u–v kenarı var mı? getEdge | O(m) | O(min(deg u, deg v)) | O(1) |
| v'nin komşularını gez | O(m) | O(deg v) | O(n) |
Çizge Gösterimleri
Java ile Komşuluk Listesi
class Cizge { private final int n; // düğümler: 0..n-1 private final List<List<Integer>> komsu = new ArrayList<>(); Cizge(int n) { this.n = n; for (int i = 0; i < n; i++) komsu.add(new ArrayList<>()); } void kenarEkle(int u, int v) { komsu.get(u).add(v); komsu.get(v).add(u); // yönlü çizgede bu satır yok } List<Integer> komsular(int u) { return komsu.get(u); } // O(1) int derece(int u) { return komsu.get(u).size(); } }
boolean[][] m = new boolean[n][n]; kenar ekle: m[u][v] = m[v][u] = true; sorgu m[u][v] O(1).int[]{v, w} veya küçük bir Kenar sınıfı; matriste int[][], kenar yoksa Integer.MAX_VALUE.Gezinme (BFS / DFS)
Gezinme Algoritmaları
Gezinme (traversal): bir başlangıç düğümünden ulaşılabilen tüm düğümleri, her birini bir kez sistematik olarak ziyaret etmek.
boolean[] ziyaret) şarttır; yoksa algoritma sonsuza kadar döner.Gezinme (BFS / DFS)
Genişlik Öncelikli Arama (BFS)
- Düğümleri seviye seviye keşfeder: önce başlangıca 1 kenar uzaklıktakiler, sonra 2 kenar uzaklıktakiler…
- Kuyruk yapısını kullanır: ilk keşfedilen ilk işlenir.
- Her düğüm yalnızca bir kez ziyaret edilir.
Artıları
- Ağırlıksız çizgede en kısa yolu (en az kenar) bulur.
- Yakın düğümleri hızlı keşfeder.
Eksisi
- Bellek kullanımı yüksek olabilir: bir seviyenin tamamı kuyrukta bekler.
Gezinme (BFS / DFS)
BFS Algoritması
BFS(başlangıç): kuyruk.ekle(başlangıç) başlangıç.ziyaretEdildi() while kuyruk boş değil: w = kuyruk.çıkar() for w'nin ziyaret edilmemiş her komşusu u: u.ziyaretEdildi() kuyruk.ekle(u)
Düğüm kuyruğa girerken işaretlenir; böylece aynı düğüm kuyruğa iki kez girmez.
void bfs(int s) { boolean[] ziyaret = new boolean[n]; Queue<Integer> q = new ArrayDeque<>(); ziyaret[s] = true; q.add(s); while (!q.isEmpty()) { int w = q.poll(); System.out.print(w + " "); for (int u : komsu.get(w)) if (!ziyaret[u]) { ziyaret[u] = true; q.add(u); } } }
Gezinme (BFS / DFS)
BFS Adım Adım (başlangıç: A)
Başlangıç: A ziyaret edildi olarak işaretlenir ve kuyruğa eklenir.
A çıkarılır; ziyaret edilmemiş komşuları B, F, I işaretlenip kuyruğa eklenir.
B çıkarılır; ziyaret edilmemiş komşuları C, E işaretlenip kuyruğa eklenir.
F çıkarılır; ziyaret edilmemiş komşuları G işaretlenip kuyruğa eklenir.
I çıkarılır; ziyaret edilmemiş komşusu yok, kuyruğa bir şey eklenmez.
C çıkarılır; ziyaret edilmemiş komşuları D işaretlenip kuyruğa eklenir.
E çıkarılır; ziyaret edilmemiş komşusu yok, kuyruğa bir şey eklenmez.
G çıkarılır; ziyaret edilmemiş komşusu yok, kuyruğa bir şey eklenmez.
D çıkarılır; ziyaret edilmemiş komşuları H işaretlenip kuyruğa eklenir.
H çıkarılır; ziyaret edilmemiş komşusu yok, kuyruğa bir şey eklenmez. Kuyruk boş: gezinme biter. Sıra: A B F I C E G D H
Gezinme (BFS / DFS)
Derinlik Öncelikli Arama (DFS)
- Düğümleri bir yol boyunca keşfeder: gidebildiği kadar derine iner.
- Çıkmaza gelince (ziyaret edilmemiş komşu kalmayınca) geri döner (backtracking) ve başka dalı dener.
- Yığın (stack) yapısı veya özyinelemeli çağrılar kullanılır.
- Her düğüm yalnızca bir kez ziyaret edilir.
Artıları
- Bellek kullanımı genellikle düşüktür (yalnızca mevcut yol yığında).
- Bir yolun sonuna kadar gitme yeteneği sağlar.
Eksisi
- En kısa yolu garanti etmez.
Gezinme (BFS / DFS)
DFS Algoritması
void dfs(int v, boolean[] ziyaret) { ziyaret[v] = true; System.out.print(v + " "); for (int u : komsu.get(v)) if (!ziyaret[u]) dfs(u, ziyaret); }
Özyineleme, yığını bizim yerimize çağrı yığını (Bölüm 4) ile tutar.
void dfsYigin(int s) { boolean[] ziyaret = new boolean[n]; Deque<Integer> yigin = new ArrayDeque<>(); yigin.push(s); ziyaret[s] = true; while (!yigin.isEmpty()) { int v = yigin.peek(); Integer yeni = null; for (int u : komsu.get(v)) if (!ziyaret[u]) { yeni = u; break; } if (yeni == null) yigin.pop(); // geri dön else { ziyaret[yeni] = true; yigin.push(yeni); } } }
Gezinme (BFS / DFS)
DFS Adım Adım (başlangıç: A)
Başlangıç: A yığına eklenir ve ziyaret edilir.
A'nin ilk ziyaret edilmemiş komşusu B → yığına eklenir.
B'nin ilk ziyaret edilmemiş komşusu C → yığına eklenir.
C'nin ilk ziyaret edilmemiş komşusu D → yığına eklenir.
D'nin ilk ziyaret edilmemiş komşusu G → yığına eklenir.
G'nin ilk ziyaret edilmemiş komşusu E → yığına eklenir.
E: tüm komşuları ziyaret edilmiş → yığından çıkarılır (geri dönüş); G'nin ilk ziyaret edilmemiş komşusu F → yığına eklenir.
F, G sırayla çıkarılır (geri dönüş).
D'nin ilk ziyaret edilmemiş komşusu H → yığına eklenir.
H, D, C, B sırayla çıkarılır (geri dönüş).
A'nin ilk ziyaret edilmemiş komşusu I → yığına eklenir.
I, A sırayla çıkarılır (geri dönüş). Yığın boş: bitti. Sıra: A B C D G E F H I
Gezinme (BFS / DFS)
BFS ve DFS Karşılaştırması
| BFS | DFS | |
|---|---|---|
| Yardımcı yapı | Kuyruk (FIFO) | Yığın (LIFO) / özyineleme |
| Zaman (komşuluk listesi) | O(n + m) | O(n + m) |
| Ek bellek | O(n): en geniş seviye kuyrukta | O(n): en uzun yol yığında |
| En kısa yol? | Evet (ağırlıksız çizgede) | Hayır |
| Tipik kullanım | en az adım, seviye bulma | döngü tespiti, bileşenler, labirent |
Sıralar, komşuların alfabetik sırayla gezildiği varsayımıyla elde edildi; komşu sırası değişirse ziyaret sırası da değişir.
En Kısa Yol
Ağırlıksız En Kısa Yol Problemi
- Kaynak düğümden diğer tüm düğümlere olan en kısa yolları bulur (tek kaynaklı en kısa yol).
- Her kenarın aynı ağırlığa (1) sahip olduğu varsayılır: yol uzunluğu = kenar sayısı.
- Çözüm: BFS. Seviye k'daki düğümün uzaklığı tam olarak k'dır.
Kaynak 1; düğümlerin yanındaki sayı 1'e uzaklık
En Kısa Yol
Ağırlıksız En Kısa Yol Algoritması
mesafe[tüm v] = ∞ mesafe[s] = 0 kuyruk.ekle(s) while kuyruk boş değil: w = kuyruk.çıkar() for w'nin her komşusu u: if mesafe[u] == ∞: mesafe[u] = mesafe[w] + 1 kuyruk.ekle(u) return mesafe
"mesafe = ∞" aynı zamanda "ziyaret edilmedi" demektir; ayrı bir dizi gerekmez.
Map<Integer, Integer> agirliksizEnKisaYol(int s) { Map<Integer, Integer> mesafe = new HashMap<>(); for (int v : cizge.keySet()) mesafe.put(v, Integer.MAX_VALUE); // ∞ mesafe.put(s, 0); Queue<Integer> kuyruk = new LinkedList<>(); kuyruk.offer(s); while (!kuyruk.isEmpty()) { int w = kuyruk.poll(); for (int u : cizge.get(w)) if (mesafe.get(u) == Integer.MAX_VALUE) { mesafe.put(u, mesafe.get(w) + 1); kuyruk.offer(u); } } return mesafe; }
En Kısa Yol
Ağırlıksız En Kısa Yol Adım Adım
Başlangıç: mesafe[A] = 0, diğerleri ∞; A kuyruğa eklenir.
A çıkarılır; komşuları B, F, I'nın mesafesi ∞ → 0 + 1 = 1, kuyruğa eklenir.
B çıkarılır; A zaten 0, C ve E ∞ → 1 + 1 = 2.
F çıkarılır; G ∞ → 2 (A'nın mesafesi değişmez).
I çıkarılır (yeni komşu yok); C çıkarılır, D ∞ → 2 + 1 = 3.
E ve G çıkarılır; tüm komşularının mesafesi zaten belli, değişiklik yok.
D çıkarılır; H ∞ → 3 + 1 = 4.
H çıkarılır; kuyruk boş. Sonuç: A 0 · B, F, I 1 · C, E, G 2 · D 3 · H 4.
En Kısa Yol
Ağırlıklı En Kısa Yol Problemi
- Kaynak düğümden diğer tüm düğümlere olan en kısa yolları bulur.
- Her kenarın farklı bir ağırlığı olabilir: uzaklık, süre, maliyet…
- Yol uzunluğu = kenar ağırlıklarının toplamı.
A'dan F'ye en kısa yol: A → C → E → D → F = 2 + 3 + 4 + 11 = 20
En Kısa Yol
Dijkstra Algoritması: Fikir ve Sözde Kod
- Kesinleşmemiş düğümlerden mesafesi en küçük olanı seç.
- Komşuların mesafesini gevşetme ile güncelle.
- Seçim için öncelikli kuyruk, yolu kurmak için
önceki[]kullan.
Dijkstra(G, s): for her düğüm v: mesafe[v] = ∞ önceki[v] = tanımsız mesafe[s] = 0 Q = tüm düğümler // öncelikli kuyruk while Q boş değil: u = Q.çıkar() // en küçük mesafe[u] for u'nun Q'daki her komşusu v: alt = mesafe[u] + ağırlık(u, v) if alt < mesafe[v]: mesafe[v] = alt önceki[v] = u // Q'da v'nin önceliğini azalt
En Kısa Yol
Dijkstra Algoritması: Java
int[] dijkstra(List<List<int[]>> adj, int s) { // adj.get(u): {komşu, ağırlık} dizileri int[] d = new int[adj.size()]; Arrays.fill(d, Integer.MAX_VALUE); d[s] = 0; PriorityQueue<int[]> pq = // {düğüm, mesafe}, mesafeye göre new PriorityQueue<>((a, b) -> Integer.compare(a[1], b[1])); pq.add(new int[]{s, 0}); while (!pq.isEmpty()) { int[] e = pq.poll(); int u = e[0]; if (e[1] > d[u]) continue; // bayat kayıt: atla for (int[] k : adj.get(u)) { int v = k[0], alt = d[u] + k[1]; if (alt < d[v]) { d[v] = alt; pq.add(new int[]{v, alt}); } } } return d; }
PriorityQueue'sunda "önceliği azalt" yok: yeni kayıt eklenir, eskisi çıkınca bayat olarak atlanır. Yol için güncellemeye onceki[v] = u; eklenir.En Kısa Yol
Dijkstra Adım Adım (kaynak: A)
Başlangıç: mesafe[A] = 0, diğerleri ∞. Öncelik kuyruğunda yalnızca (A, 0) var.
En küçük mesafeli A (0) çıkarılır ve kesinleşir. B: ∞ → 4; F: ∞ → 7; I: ∞ → 3.
En küçük mesafeli I (3) çıkarılır ve kesinleşir. Kesinleşmemiş komşusu yok.
En küçük mesafeli B (4) çıkarılır ve kesinleşir. C: ∞ → 5; E: ∞ → 6.
En küçük mesafeli C (5) çıkarılır ve kesinleşir. D: ∞ → 12; E: 5 + 3 = 8 ≥ 6, değişmez.
En küçük mesafeli E (6) çıkarılır ve kesinleşir. G: ∞ → 8.
En küçük mesafeli F (7) çıkarılır ve kesinleşir. G: 7 + 2 = 9 ≥ 8, değişmez.
En küçük mesafeli G (8) çıkarılır ve kesinleşir. D: 12 → 11.
En küçük mesafeli D (11) çıkarılır ve kesinleşir. H: ∞ → 16.
En küçük mesafeli H (16) çıkarılır ve kesinleşir. Kesinleşmemiş komşusu yok.
Yolu bulmak için önceki zinciri geri izlenir: H ← D ← G ← E ← B ← A. Yol: A → B → E → G → D → H = 4 + 2 + 2 + 3 + 5 = 16.
En Kısa Yol
Dijkstra Algoritmasının Analizi
| Uygulama | Karmaşıklık | Neden? |
|---|---|---|
| Öncelikli kuyruk (ikili heap) | O((n + m) log n) | n kez en küçüğü çıkar, en çok m kez güncelle/ekle; her biri O(log n) |
| Kuyruksuz (dizi taraması) | O(n² + m) = O(n²) | Her adımda en küçük mesafeli düğümü bulmak için n düğüm taranır; komşu kontrolleri toplam m |
Özet
Özet
| Algoritma | Yapı | Zaman (liste ile) | Ne verir? |
|---|---|---|---|
| BFS | kuyruk | O(n + m) | seviye sırası, ağırlıksız en kısa yol |
| DFS | yığın / özyineleme | O(n + m) | derinlemesine gezinme, döngü, bileşenler |
| Dijkstra | öncelikli kuyruk | O((n + m) log n) | ağırlıklı en kısa yol (ağırlık ≥ 0) |
Özet
Etkileşimli Simülatörler
Bu bölümün konularını tarayıcıda deneyerek pekiştirin:
Özet
Örnek Problemler
- 10 düğümlü basit yönsüz bir çizgede en fazla kaç kenar olabilir? Derecelerin toplamı 30 ise kaç kenar vardır?
- n = 10.000 düğüm, m = 30.000 kenar olan bir yol ağını hangi gösterimle saklarsınız? Neden?
- Gezinme örneğindeki çizgede BFS ve DFS'yi H'den başlatın (komşular alfabetik).
- DFS'yi yığın yerine kuyrukla yazarsak hangi algoritmayı elde ederiz?
- Ağırlıklı en kısa yol örneğinde B → C kenarı 5 yerine 1 olsaydı A'dan D'ye en kısa yol ne olurdu?
Cevapları göster
- 10·9/2 = 45 kenar; Σ deg = 2m → m = 15.
- Komşuluk listesi: O(n + m) ≈ 40 bin kayıt; matris 10⁸ hücre ister ve çoğu 0 olur.
- BFS: H D C G B E F A I · DFS: H D C B A F G E I.
- Ziyaret sırası BFS'ye dönüşür (ön kısım kuyruk mantığıyla işlenir).
- A → C yolu değişmez (2 < 4 + 1); D için A → C → E → D = 2 + 3 + 4 = 9, yine 9.
Ö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.
Son
← → veya boşluk ile gezinin · F: tam ekran · Home/End: ilk/son slayt