Açık Veri Yapıları ( Java ile )
advertisement
AÇIK VERİ YAPILARI (JAVA İLE) Pat Morin Türkçeye Çeviren: Ayşegül Tunç 2| AÇIK VERİ YAPILARI (JAVA İLE) Pat Morin Türkçeye Çeviren: Ayşegül Tunç Yazarı (Author): Pat MORIN (Canadian Scientist) Türkçeye Çeviren: Ayşegül Tunç Sayfa Düzenleme & Grafik Tasarım: e-KiTAP PROJES Kapak Tasarımı: © E-Kitap Projesi, Editorial: Banu Fi ek & Fulya Saatçıo lu Yayıncı (Publisher): http://www.ekitaprojesi.com, Murat Ukray Baskı ve Cilt (Print Publisher): www.lulu.com Yayıncı Sertifika Numarası (Publisher Certificate Number): 32712 Istanbul, Ocak (January) 2016 ISBN: 978-1-329-86063-6 Yazar & Kitap leti im (Author Contact): (e-mail & web): [email protected] www.ekitaprojesi.com/books/acik-veri-yapilari-java-ile www.facebook.com/EKitapProjesi Bu Kitabın çeviri hakları, yazarın yazılı izni ile e-Kitap Projesi ile Çevirmen Ayşegül Tunç’a aittir. İzin alınmadan kısmen veya tamamen kopyalanması yasaktır.. © Bu eserin basım ve yayın hakları yazarın kendisine aittir. Fikir ve Sanat Eserleri Yasası gereğince, izinsiz kısmen veya tamamen çoğaltılıp yayınlanamaz. Kaynak gösterilerek kısa alıntı yapılabilir. |3 KİTAP HAKKINDA...................................................................................................... 9 YAZAR HAKKINDA ................................................................................................... 11 ÇEVİRMEN HAKKINDA ............................................................................................ 13 BÖLÜM 1 ................................................................................................................... 15 Giriş ........................................................................................................................... 15 Verimlilik Gereksinimi ................................................................................... 17 Arayüzler............................................................................................................ 21 Kuyruk, Yığıt ve İki Başlı Kuyruk Arayüzleri .................................... 22 Liste Arayüzü: Doğrusal Diziler .................................................................. 25 UKüme Arayüzü: Sıralı Olmayan Kümeler ...................................... 27 SKüme Arayüzü: Sıralı Kümeler ......................................................... 29 Matematiksel Zemin ...................................................................................... 31 Üslüler ve Logaritmalar ........................................................................... 31 Faktöryeller.................................................................................................. 34 Asimptotik Gösterim ................................................................................. 36 Rasgele Sıralama ve Olasılık ................................................................. 43 Hesaplama Modeli .............................................................................................. 47 Doğruluk, Zaman Karmaşıklığı ve Alan Karmaşıklığı......................... 49 Kod Örnekleri ................................................................................................... 53 Veri Yapıları Listesi ......................................................................................... 54 Tartışma ve Alıştırmalar ............................................................................... 56 BÖLÜM 2 ................................................................................................................... 61 Dizi-Tabanlı Listeler............................................................................................. 61 Dizi Yığıtı: Dizi Kullanan Hızlı Yığıt İşlemleri ......................................... 63 Temel Bilgiler .............................................................................................. 64 Büyültme ve Küçültme ............................................................................ 67 Özet ................................................................................................................ 71 Hızlı Dizi Yığıtı: Optimize Dizi Yığıtı .......................................................... 72 Dizi Kuyruğu: Dizi-Tabanlı Kuyruk ........................................................... 74 4| Özet ................................................................................................................ 79 Dizi İki Başlı Kuyruk: Dizi Kullanan Hızlı İki Başlı Kuyruk ............... 80 Özet ................................................................................................................ 83 Çifte Dizi İki Başlı Kuyruk: İki Yığıt’tan İki Başlı Kuyruk Oluşturulması................................................................... 84 Dengeleme ................................................................................................... 89 Özet ................................................................................................................ 92 Kök Dizi Yığıt: Alan Kriteri Verimli Olan Dizi Yığıt Uygulaması ...... 93 Büyültme ve Küçültmenin Analizi ...................................................... 100 Alan Kullanımı ........................................................................................... 101 Özet .............................................................................................................. 103 Karekökleri Hesaplamak ....................................................................... 104 Tartışma ve Alıştırmalar ............................................................................. 109 BÖLÜM 3 ................................................................................................................. 113 Bağlantılı Listeler ................................................................................................ 113 TBListe: Tekli-Bağlantılı Liste ................................................................... 114 Kuyruk İşlemleri ....................................................................................... 117 Özet .............................................................................................................. 118 ÇBListe: Çifte-Bağlantılı Liste ................................................................... 119 Ekleme ve Çıkarma ................................................................................. 122 Özet .............................................................................................................. 124 AVListe: Alan-Verimli Liste ........................................................................ 126 Alan Gereksinimleri ................................................................................. 128 Elemanların Bulunması .......................................................................... 128 Elemanların Eklenmesi........................................................................... 131 Elemanların Silinmesi ............................................................................. 134 yayıl(u) ve birarayaGetir(u) Yöntemlerinin Amortize Edilmiş Analizi ........................................................................ 137 Özet .............................................................................................................. 140 Tartışma ve Alıştırmalar ............................................................................. 142 BÖLÜM 4 ................................................................................................................. 113 Sekme Listeleri ................................................................................................... 150 Temel Yapı ....................................................................................................... 151 Sıralı Küme Sekme Listesi: Verimli bir Sıralı Küme ......................... 155 Özet .............................................................................................................. 159 |5 Liste Sekme Listesi: Verimli Rasgele Erişim Listesi ......................... 160 Özet .............................................................................................................. 167 Sekme Listelerinin Analizi .......................................................................... 168 Tartışma ve Alıştırmalar ............................................................................. 174 BÖLÜM 5 ................................................................................................................. 181 Karma Tabloları .................................................................................................. 181 Zincirleme Karma Tablo: Zincirleme İle Adresleme ........................ 182 Çarpımsal Karma Yöntemi.................................................................... 186 Özet .............................................................................................................. 193 Doğrusal Karma Tablo: Doğrusal Yerleştirme .................................... 194 Doğrusal Yerleştirme Analizi ............................................................... 199 Özet .............................................................................................................. 204 Listeleme Karma Yöntemi .................................................................... 205 Karma Kodları ................................................................................................ 207 Temel Veri Türleri için Karma Kodları .............................................. 208 Bileşik Nesneler için Karma Kodları .................................................. 209 Diziler ve Dizeler için Karma Kodları ................................................ 213 Tartışma ve Alıştırmalar ............................................................................. 217 BÖLÜM 6 ................................................................................................................. 224 İkili Ağaçlar .......................................................................................................... 224 İkili Ağaç: Temel İkili Ağaç ....................................................................... 227 Özyinelemeli Algoritmalar .................................................................... 228 İkili Ağaçta Sıralı-Düğüm Ziyaretleri ................................................ 229 Serbest Yükseklikli İkili Arama Ağacı .................................................... 234 Arama .......................................................................................................... 235 Ekleme ......................................................................................................... 238 Silme ............................................................................................................ 240 Özet .............................................................................................................. 243 Tartışma ve Alıştırmalar ............................................................................. 245 BÖLÜM 7 ................................................................................................................. 253 Rasgele İkili Arama Ağaçları .......................................................................... 253 Rasgele İkili Arama Ağaçları ..................................................................... 253 Önerme 7.1’in Kanıtı .............................................................................. 258 Özet .............................................................................................................. 262 6| Treap: Rasgele İkili Arama Ağaçları....................................................... 263 Özet .............................................................................................................. 272 Tartışma ve Alıştırmalar ............................................................................. 276 BÖLÜM 8 ................................................................................................................. 284 Günah Keçisi Ağaçları ....................................................................................... 284 Günah Keçisi Ağacı: Kısmi Yeniden Oluşturmalı İkili Arama Ağacı ................................................................... 286 Doğruluk Analizi ve Çalışma Zamanı ................................................ 291 Özet .............................................................................................................. 296 Tartışma ve Alıştırmalar ............................................................................. 297 BÖLÜM 9 ................................................................................................................. 304 Kırmızı-Siyah Ağaçlar ....................................................................................... 304 2-4 Ağaçları..................................................................................................... 306 Yaprak eklenmesi .................................................................................... 307 Yaprak silinmesi ....................................................................................... 309 Kırmızı-Siyah Ağacı: 2-4 Ağacının Benzeri .......................................... 311 Kırmızı-Siyah Ağacı ve 2-4 Ağacı ....................................................... 313 Kırmızı-Siyah Ağacında Sola-Dayanım ............................................ 318 Ekleme ......................................................................................................... 321 Silme ............................................................................................................ 325 Özet.................................................................................................................... 334 Tartışma ve Alıştırmalar ............................................................................. 337 BÖLÜM 10 .............................................................................................................. 344 Yığınlar ................................................................................................................... 344 İkili Yığın: Bir Örtülü İkili Ağaç ................................................................ 344 Özet .............................................................................................................. 352 Karışık Yığın: Rasgele Karışık Yığın ........................................................ 353 merge(h1, h2) Analizi ............................................................................ 357 Özet .............................................................................................................. 360 Tartışma ve Alıştırmalar ............................................................................. 361 BÖLÜM 11 .............................................................................................................. 365 Sıralama Algoritmaları...................................................................................... 365 Karşılaştırmaya-Dayalı Sıralamalar ........................................................ 367 Birleştirerek-Sıralama ............................................................................ 368 Hızlı-Sıralama ............................................................................................ 373 |7 Yığın-Sıralama .......................................................................................... 379 Karşılaştırmaya Dayalı Sıralama için Alt-Sınır .............................. 383 Sayma Sıralama ve Taban Sıralaması .................................................. 388 Sayma Sıralaması.................................................................................... 389 Taban-Sıralaması..................................................................................... 392 Tartışma ve Alıştırmalar ............................................................................. 395 BÖLÜM 12 .............................................................................................................. 401 Grafikler................................................................................................................. 401 Bitişiklik Matrisi: Bir Grafiğin Matris ile Gösterimi ............................ 404 Bitişiklik Listeleri: Liste Derlemi olarak Grafik ................................... 409 Grafik Ziyaretleri ........................................................................................... 415 Enine-Arama ............................................................................................. 416 Derinliğine Arama.................................................................................... 419 Tartışma ve Alıştırmalar ............................................................................. 424 BÖLÜM 13 .............................................................................................................. 429 Tamsayılar için Veri Yapıları ........................................................................... 429 İkili Sıralı Ağaç: Sayısal Arama Ağacı ................................................... 431 X-Hızlı Sıralı Ağaç: Çifte-Logaritmik Zamanda Arama .................... 439 Y-Hızlı Sıralı Ağaç: Çifte-Logaritmik Zamanlı Sıralı Küme ............. 444 Tartışma ve Alıştırmalar ............................................................................. 453 BÖLÜM 14 .............................................................................................................. 457 Dış Bellek Aramaları.......................................................................................... 457 Blok Deposu .................................................................................................... 460 B-Ağaçları ........................................................................................................ 462 Arama .......................................................................................................... 466 Ekleme ......................................................................................................... 470 Silme ............................................................................................................ 476 B-Ağaç’ların Amortize Analizi .............................................................. 484 Tartışma ve Alıştırmalar ............................................................................. 489 KAYNAKÇA (BİBLİOGRAPHY) ............................................................................. 495 8| |9 Kitap Hakkında Açık Veri Yapıları, dizi (liste), kuyruk, öncelikli kuyruk, sırasız küme, sıralı küme ve grafik gibi veri yapıları için geliştirilmiş uygulama ve veri yapılarının analizini kapsar. Hızlı, pratik, titiz ve verimli bir matematiksel yaklaşım üzerinde yoğunlaşırken, Morin açıkça ve dinamik olarak kaynak kod ile birlikte birtakım çözümlemeler sunar. Java dilinde analiz edilmiş ve uygulanmış veri yapıları, kitapta sunulan, yığıt, kuyruk ve listelerin dizi ve bağlantılı liste uygulamalarını; liste ve sekme listelerinin alan-verimli uygulamalarını; karma tabloları ve karma kodlarını; x-hızlı sıralı ağaç ve y-hızlı sıralı ağaç üzerinde tamsayı arama yapılarını; grafikleri, bitişiklik matrislerini ve B-ağaçlarını içerir. https://archive.org/details/ost-computer-science-odstructuresjava adresinde kitabın orijinal baskısını bulabilirsiniz. 10| | 11 Yazar Hakkında PAT MORIN, Carleton Üniversitesi’nde Bilgisayar Bilimleri Okulu’nda Profesör olmasının yanı sıra, açık erişimli Hesaplamalı Geometri Dergisi’nin kurucusu ve yönetici editörüdür. Hesaplamalı geometri, algoritmalar ve veri yapıları konularında çok sayıda konferans makaleleri ve dergi yayınlarının yazarıdır. 12| | 13 Çevirmen Hakkında AYŞEGÜL TUNÇ, 1971 yılında Ankara'da dünyaya geldi. İlkokulu TED Ankara Koleji'nde, ortaokul ve liseyi Ankara Atatürk Anadolu Lisesi'nde takdirname derecesi ile bitirdi. Üniversitede birinci tercihine girdi ve burslu okudu. Annesinin vefatı ve babasının rahatsızlığı nedeniyle çalışmıyor. Ev-ofisinde yaptığı iş Internet-tabanlı betik programlar geliştirmek ve bilgisayar bilimleri alanına ait dikkatini çeken konularda Türkçeye çeviriler yapmaktadır. Son yıllarda “İşbirliğine Dayalı Öğrenme ve Açık Eğitim Hareketi” kapsamında serbest lisanslamalar artış gösterdi. Çevirmen de bu uygulamalar arasından seçimlerde bulunarak işe başladı. 14| | 15 Bölüm 1 Giriş Dünyadaki bilgisayar bilimleri öğretim programlarının tümünde, veri yapıları ve algoritmalar üzerine bir ders içeriği bulunmaktadır. Veri yapıları bu kadar önemlidir; her gün, hafta ve ay bizi tehlike, zarar ve başarısızlıktan korur, böylece daha başarılı oluruz. Pek çok multi-milyon ve multi-milyar liralık şirketler ihtiyaçları veya gereksinimlerine uygun, birçok veri yapısı etrafında yapılandırılmışlardır. Bu nasıl olabilir? Eğer biraz düşünürsek, veri yapıları ile belirli bir süre boyunca çok sık veya her zaman etkileşim içinde olduğumuzu anlarız. Dosya açmak: Dosya sistemine ait veri yapıları bir dosyanın parçalarını diskte bulmak için kullanılır, böylece o dosyaya erişebiliriz. Bu kolay değildir; diskler yüzlerce milyon blok içerir. Dosyanızın içeriği bunlardan herhangi biri üzerinde depolanmış olabilir. Telefonunuzda kayıtlı olan bir kişiye bakmak: Siz arama- yı/yazmayı bitirmeden önce, kısmi bilgiye dayalı olarak kişi listesindeki bir telefon numarasını aramak için bir veri yapısı kullanılır. Bu kolay değildir; telefonuzda pek çok insan hakkında bilgiler ka- 16| yıtlı olabilir - telefon veya e-posta yoluyla görüştüğünüz herkes ve telefonunuzun çok hızlı bir işlemcisi, veya belleği olmak zorunda değildir. En sevdiğiniz sosyal ağınıza giriş yapmak: Ağ sunucuları, he- sap bilgilerinize bakmak için giriş bilgilerinizi kullanır. Bu kolay değildir; en popüler sosyal ağlar yüzlerce milyon aktif kullanıcı içerir. Web araması yapmak: Arama motoru, arama terimlerinizi içe- ren web sayfalarını bulmak için veri yapılarını kullanır. Bu kolay değildir; Internet üzerinde 8,5 milyarın üzerinde web sayfası vardır ve her sayfa pek çok potansiyel arama terimlerini içerir. Telefon acil durum hizmetleri (1-5-5): Polis arabaları, ambu- lanslar ve itfaiye araçları gecikmeden adresinize gönderilsin diye, acil servis şebekeleri, telefon numaralarını adreslerle eşleştiren bir veri yapısı kullanarak sizin telefon numaranızı arar. Bu önemlidir; çağrıyı yapan kişinin tam adresini vermesi mümkün olmayabilir ve bir gecikme ölüm kalım arasındaki fark anlamına gelebilir. | 17 Verimlilik Gereksinimi Bir sonraki bölümde, en sık kullanılan veri yapıları tarafından desteklenen işlemlere bakacağız. Biraz programlama deneyimi olan herkes, bu işlemleri doğru olarak gerçekleştirmenin zor olmadığını görecektir. Verileri, muhtemelen, bir dizi veya bağlantılı-listede depolayabiliriz ve dizi veya listedeki tüm elemanlar üzerinden yineleme yaparak, örneğin, bir elemanı ekleyebilir veya silebiliriz. Bu tür bir uygulama kolaydır, ancak çok verimli değildir. Bu gerçekten önemli midir? Bilgisayarlar hızlı ve gitgide daha hızlı hale gelmektedir. Belki, anlaşılması kolay olan uygulama daha iyidir. Yaklaşık hesaplamalar yaparak öğrenmeye çalışalım. 6 İşlem sayısı: 1 milyon (10 ) elemanı olan, orta ölçekte bir veri kümesi kullanan uygulamayı düşünün. Bu uygulamanın en az bir defa her elemanı aramak istemesi, çoğu uygulama için makul bir varsa6 yımdır. Bu demektir ki, veri içinden en az 1 milyon (10 ) arama 6 yapmayı bekleyebiliriz. Her arama için, 10 inceleme yapılacaksa, 6 6 12 toplamda bu, 10 x 10 = 10 (bir trilyon) arama eder. İşlemci hızları: Çok hızlı bir masaüstü bilgisayar bile, saniyede bir 9 milyardan fazla (10 ) yazdırma işlemi yapamaz. Bu demektir ki, bir uygulama en az 10 12 9 / 10 = 1.000 saniye veya yaklaşık 16 dakika ve 40 saniye alacaktır. Onaltı dakika bilgisayar zamanı için birçok 18| uzun bir zamandır, kahve molası vermek için dışarıya yönelen bir kişi ancak bu zamanı ayırabilir. Büyük veri setleri: Şimdi 8,5 milyar’ın üzerinde web sayfasını endeksleyen, Google gibi bir şirket düşünün. Hesaplarımıza göre, bu veriler üzerinde yapılacak her türlü sorgu en az 8,5 saniye sürer. Ancak, bu durumda olmadığımızı zaten biliyoruz; web aramaları 8,5 saniyeden çok daha az sürede tamamlanıyor ve belirli bir sayfanın kendilerine endeksli sayfalar içinde olup olmadığını sormak yanında, çok daha karmaşık sorguları da yapabiliyorlar. Google, saniyede yaklaşık 4.500 sorgu gerçekleştirir, bu işi yürütebilmeleri için, en az 4.500 x 8,5 = 38.250 sayıda çok hızlı sunucuya gereksinim duyarlar. Çözüm: Bu örnekler bize şunu söylemektedir: Veri yapısındaki eleman sayısı olan n, ve gerçekleştirilen işlem sayısı olan, m, verildiğinde özellikle her ikisi de büyük olduğunda, besbelli algoritmalar için iyi ölçeklendirme sağlanamamaktadır. Yaklaşık bir hesaplamayla, bu algoritmalar için gerekli olan çalışma zamanı (diyelim ki, makine komutu cinsinden ölçüldüğünde) n x m olarak hesaplanır. Çözüm, tabii ki, her işlemin her elemanı kontrol etmemesidir, bunu sağlayacak şekilde veri yapısı içindeki verilerin dikkatle düzenlenmesi gerekiyor. Veri yapısı içinde depolanmış bulunan eleman sayısından bağımsız olarak, sadece ortalama iki elemana bakarak arama yapabilen veri yapılarını göreceğiz. Bilgisayarınız, saniyede | 19 milyar komut çalıştırabiliyorsa, bir milyar (veya bir trilyon, bir katrilyon ve hatta bir kentilyon) eleman içeren bir veri yapısı içinde arama yapmak, sadece 0,000000002 saniye alacaktır. Sıralı veri tutan bir yapı için, eleman sayısına bağlı olarak, bir işlem sırasında kontrol edilen eleman sayısı çok yavaş büyüme kaydedebilir. Örneğin, herhangi bir işlem sırasında, en fazla 60 elemanı kontrol edecek şekilde, bir milyar elemanı sıralı olarak tutabiliriz. Saniyede milyar komut çalıştırabilen bilgisayarınızda, bu işlemler 0,00000006 saniye alacaktır. Bu bölümün kalan kısmında, bazı temel kavramları yorumlayacağız. Arayüzler Bölümü’nde, kitapta anlatılan veri yapılarının tamamı tarafından gerçekleştirilen arayüzler açıklanıyor ve okunması için gereken dikkati vermelisiniz. Kalan bölümlerde şunları tartışacağız: Üsler, logaritma, faktöriyel, asimptotik (büyük-Oh) gösterimi, olasılık ve randomizasyon dahil olmak üzere bazı matematiksel incelemeler; Hesaplama modeli; Doğruluk, yürütme zamanı ve alanı; Kalan bölümlere genel bir bakış, ve Örnek kod ve dizgi kuralları. 20| Bu alanlarda birikim sahibi olan veya olmayan okuyucular için, şimdilik bu tartışmalar atlanabilir, ve gerekirse, daha sonra tekrar geri dönüş sağlanabilir. | 21 Arayüzler Veri yapılarını tartışırken, bir veri yapının arayüzü ile uygulaması arasındaki farkı anlamak önem arz eder. Arayüz bir veri yapısının ne yaptığını açıklarken, uygulaması bunu nasıl yaptığını açıklar. Bazen, soyut veri türü olarak da adlandırılan arayüz, bir veri yapısı tarafından desteklenen işlem kümesini ve bu işlemlerin semantiğini, yani anlamını, tanımlar. Arayüz, veri yapısının bu işlemleri nasıl gerçekleştirdiğine dair hiçbir şey söylemez; sadece desteklenen işlemlerin bir listesini ve her işlemin ne tür argümanları kabul ettiğini ve döndürdükleri değer hakkındaki gereksinimleri belirtir. Bir veri yapısını gerçekleştirmek, diğer taraftan, veri yapısının iç gösterimini ve aynı zamanda veri yapısı tarafından desteklenen işlemleri uygulamaya koyan algoritmaların tanımlarını içerir. Bu nedenle, tek bir arayüzün birçok uygulaması olabilir. Örneğin, Liste arayüzünün uygulamalarını görürken, Bölüm 2, dizileri işleyecek; Bölüm 3, işaretçi-tabanlı veri yapılarını işleyecek. Her ikisi de aynı arayüzü, Liste’yi, farklı şekillerde uygulamıştır. 22| Kuyruk, Yığıt ve İki Başlı Kuyruk Arayüzleri Kuyruk arayüzü, elemanları ekleyebildiğimiz ve sonraki elemanı silebildiğimiz bir elemanlar topluluğunu gösterir. Daha kesin olarak, Kuyruk arayüzü tarafından desteklenen işlemler şunlardır: ekle(x): Kuyruğa x değerini sil(): ekler. Daha önceden eklenmiş bulunan y değerini kuyruktan siler, ve y değerini döndürür. sil() işleminin hiçbir argüman almadığına dikkat ediniz. Kuyruk’un kuyruklama disiplini hangi elemanın kaldırılması gerektiğine karar verir. En yaygın olarak FIFO (ilk-giren-ilk-çıkar), Öncelik Kuyruğu, ve LIFO(son-giren-ilk-çıkar) dahil olmak üzere birçok olası kuyruk disiplinleri vardır. Şekil 1.1'de gösterilen FIFO(ilk-giren-ilk-çıkar) Kuyruk’u, elemanları ekleme sırasıyla aynı sırada siler. Bunu, bir bakkalın kasasında çalışan kuyruğa (veya sıraya) benzetebiliriz. Bu, en sık rastlanan Kuyruk türüdür, bu nedenle, FIFO sıfatı genellikle ihmal edilir; kul- lanılmaz. FIFO Kuyruğu üzerindeki ekle(x) ve sil() işlemleri, sırasıyla, kuyruğa koy(x) ve kuyruktan kaldır() olarak adlandırılmıştır. | 23 Şekil 1.2'de gösterilen Öncelik Kuyruğu, her zaman, en küçük elemanı siler, bağları buna uygun olacak şekilde kırar. Bunu, bir hastanenin acil serviste hastalara servis vermesine benzetebiliriz. Hastalar, geldikçe değerlendirilir ve daha sonra bir bekleme odasına yerleştirilir. Bir doktor müsait olduğunda, ilk olarak yaşam tehditi en fazla bulunan hasta ile ilgilenir. Öncelik Kuyruğu üzerindeki sil() işlemi, silMin() olarak adlandırılmıştır. Çok yaygın bir kuyruk disiplini de Şekil 1.3'de gösterildiği gibi LIFO(son-giren-ilk-çıkar) disiplinidir. LIFO Kuyruğu’nda, en son eklenen eleman silinir. Bunu en iyi olarak, tabakların üst üste dizildiği bir tabak yığıtı şeklinde görselleştirebiliriz. Yeni bir tabağı yığıtın en üstüne dizeriz; tabak çıkarırken yığıtın en üstünden çıkarırız. Bu yapıya çok sık rastlanır ve Yığıt adı altında incelenir. Yığıt tartışılırken, ekle() ve sil() işlemleri, çoğu zaman yığ() ve yığıttan_kaldır() olarak değiştirilmiştir, bunun nedeni LIFO ve FIFO Kuyruk disiplinlerinin birbirine karıştırılmamasıdır. 24| İki Başlı Kuyruk, (Yığıt) hem FIFO Kuyruğu ve hem LIFO Kuyruğu’nun genelleştirilmiş bir halidir. Önü ve arkası bulunan eleman- lardan oluşan bir diziyi gösterir. Elemanlar dizinin başına veya sonuna eklenebilir. İki Başlı Kuyruk işlemlerinin adları da kendi kendilerini açıklayıcıdır: başaEkle(x), baştanSil(), sonaEkle(x), sondanSil(). baştanSil() Şunu belirtmeliyiz ki, Yığıt sadece başaEkle(x) ve işlemleri kullanılarak uygulanabilirken, FIFO Kuyruk da sadece sonaEkle(x) ve sondanSil() işlemleri kullanılarak uygulanabilir. | 25 Liste Arayüzü: Doğrusal Diziler Bu kitapta, FIFO Kuyruk, Yığıt veya İki Başlı Kuyruk arayüzleri hakkında çok az konuşacağız. Bunun nedeni, bu arayüzlerin, Liste arayüzü tarafından kapsanmış olmasıdır. Şekil 1.4’teki Liste, x0,…,xn-1 değerlerinden oluşan bir diziyi gösteriyor. Liste arayüzü aşağıdaki işlemleri içermektedir: 1. boyut(): 2. al(i): 3. belirle(i, x): 4. ekle(i, x): xi,…,xn – 1’in x Listenin uzunluğu olan, n, değerini döndürür. Listenin xi değerini döndürür. Listenin xi değerini x’e eşitler. değerini yerleştirir. Her j yerini değiştirerek, listenin i konumuna {n – 1,…,i} için xj + 1 = xj eşitler, n’i bir artırır, ve xi = x eşitler. 5. sil(i): xi siler. Her j + 1,…,xn – 1 ’in yerini değiştirerek, xi değerini listeden {i,…, n – 2} için xj = xj + 1 eşitler, n’i bir azaltır. Unutmayın ki, bu işlemler, İki Başlı Kuyruk arayüzünü de uygulamak için kesinlikle yeterlidir. Şöyle ki: başaEkle(x) ekle(0, x) 26| baştanSil() sil(0) sonaEkle(x) ekle(boyut(), x) sondanSil() sil(boyut() – 1) Daha sonraki bölümlerde Yığıt, İki Başlı Kuyruk ve FIFO Kuyruk arayüzleri tartışılmasa da, Yığıt ve İki Başlı Kuyruk terimleri, Liste arayüzünü gerçekleştiren bazı veri yapılarını adlandırmakta kullanılmıştır. Bu veri yapıları, Yığıt veya İki Başlı Kuyruk arayüzlerini çok verimli uygulamak DiziİkiBaşlıKuyruk için kullanılmıştır. Örneğin, sınıfı tüm İki Başlı Kuyruk işlemlerini sabit za- manda gerçekleştiren bir Liste arayüzü uygulamasıdır. | 27 UKüme Arayüzü: Sıralı Olmayan Kümeler UKüme arayüzü matematiksel bir diziye benzeyen, tekil elemanlar- dan oluşan ve sıralı olmayan bir kümeyi gösterir. Bir UKüme, n farklı eleman içerir; hiçbir eleman bir defadan fazla görünmez, ve elemanlar hiçbir belirli sırada sıralanmamıştır. Bir UKüme aşağıdaki işlemleri desteklemektedir: 1. boyut(): Kümedeki 2. ekle(x): x eleman sayısı olan, n, değerini döndürür. elemanı kümede zaten mevcut değilse, kümeye ek- ler. Kümede hiçbir y elemanı yoktur ki, x, y’ye eşit olarak hesaplanırsa, x elemanı kümeye eklensin. x kümeye eklendiği takdirde, true döndürür, 3. sil(x): ve aksi takdirde false döndürür. Kümeden x elemanını siler. Kümede öyle bir y elemanı bulur ki x, y’ye eşit olarak hesaplanırsa, y’yi silsin. Bu tür bir eleman yoksa, null, varsa y elemanını döndürür. 4. y bul(x): Kümede mevcutsa, x elemanını bulur. Kümede öyle bir elemanı bulur ki y, x’e eşit olsun. Bu tür bir eleman yoksa, null, varsa y döndürür. Bu tanımlar, sildiğimiz veya bulduğumuz değer olan x ile, silebileceğimiz veya bulabileceğimiz değer olan y arasındaki ayrımı biraz belirsiz yapıyor. Bunun nedeni, x ve y eşit olarak değerlendirilirse de, aslında farklı nesneler olabilirler. Böyle bir ayrım yararlıdır, 28| çünkü anahtarları değerlerle eşleştiren sözlük veya eşlemlerin oluşturulmasına izin verir. Bir sözlük/eşlem oluşturmak için, her biri anahtar ve değer içeren, Çiftler diye adlandırılan, bileşik nesneleri oluşturmamız gerekir. İki Çift’in anahtarları eşitse, kendileri de eşit olarak kabul edilir. (k, v) çifti bir UKüme’de depolanır, ve daha sonra x = (k, null) çifti kullanılarak bul(x) işlemi çağrılırsa, sonuç y = (k, v) olacaktır. Diğer bir deyişle, sadece anahtar, k değeri verilerek, v’yi geri kazanmak mümkündür. | 29 SKüme Arayüzü: Sıralı Kümeler SKüme arayüzü, sıralanmış elemanların bir kümesini gösterir. SKüme elemanlarının tamamı sıralı halde depolanır, böylece her- hangi iki eleman, x ve y karşılaştırılabilir. Kod örneklerinde bu, karşılaştır(x, y) adı verilen ve tanımı aşağıdaki gibi olan bir işlem- le yapılacaktır: SKüme, boyut(x), ekle(x), sil(x) işlemlerini UKüme arayüzüyle aynı anlamda olacak bir şekilde destekler. UKüme ile SKüme arasındaki fark bul(x) işlemindedir: bul(x) : Sıralı kümede x’i bulur. Kümede öyle bir en küçük y elemanı bulur ki y ≥ x olsun. Bu tür bir eleman yoksa, null, varsa y döndürür. Bu tarzdaki bul(x) işlemi, bazen bir ardıl arama olarak adlandırılır. UKüme.bul(x)’ten temel bir şekilde farklıdır, çünkü kümede x’e eşit herhangi bir eleman olmasa bile anlamlı sonuç döndürür. bul(x) işleminin UKüme ve SKüme uygulaması arasındaki ayrım çok önemlidir ve çoğu kez cevapsızdır. Bir SKüme tarafından sağlanan ekstra işlevsellik, genellikle hem daha büyük bir çalışma za- 30| manı ve hem daha yüksek bir uygulama karmaşıklığını içeren bir bedel ile birlikte gelir. Örneğin, bu kitapta tartışılan SKüme uygulamalarının çoğunda bul(x) işlemleri küme boyutu ile logaritmik bir çalışma zamanına sahiptir. Öte yandan, Bölüm 5’teki gibi UKüme’nin ZincirliKarımTablosu olarak uygulamasında sabit bek- lenen zamanda çalışan bir bul(x) işlemi sözkonusudur. Hangi yapıyı seçeceğinize karar verirken, SKüme tarafından sunulan ekstra işlevsellik gerçekten gerekli olmadıkça, her zaman bir UKüme kullanmalısınız. | 31 Matematiksel Zemin Bu bölümde, logaritma, büyük-Oh gösterimi ve olasılık teorisi de dahil olmak üzere, bu kitap boyunca kullanılan bazı matematiksel ifadeleri ve araçlarını gözden geçireceğiz. Bu yorum kısa olacaktır ve giriş olarak tasarlanmamıştır. Birikimlerinin eksik olduğunu hisseden okuyuculara, bilgisayar bilimleri için matematik [50] konusunda yazılmış çok iyi (ve ücretsiz) ders kitabını okumalarını ve alıştırmalarını çözmelerini tavsiye ediyoruz. Üslüler ve Logaritmalar x b ifadesi, b sayısının x üssüne yükseltilmiş halini gösterir. x pozitif bir tamsayıysa, bu sadece b değerinin x – 1 defa kendisiyle çarpılmış haline eşittir: x -x x negatif bir tamsayı olduğu zaman, b = 1 / b olarak hesaplanır. x x = 0 iken, b = 1 olarak hesaplanır. b tamsayı değilse, üssel fonksix yon, üssel seri olarak tanımlanan e cinsinden tanımlanabilir, ancak en iyisi bunu bir hesap analizi kitabına bırakmaktır. Bu kitapta, logb k ifadesi k’nın b-tabanlı logaritmasını ifade eder. Yani, tekil bir x değeri aşağıdaki koşulu sağlar. 32| Bu kitaptaki logaritmaların çoğu taban 2’dir (ikili logaritmadır). Bunlar için taban ihmal edilir, böylece log2 k için kısaltma log k olarak verilir. Logaritmaları düşünmenin biçimsel, ancak yararlı bir yolu da, logb k için sonuç 1'e eşit veya daha az olana dek k’nın b’ye kaç defa bölündüğünü bulmaktır. Örneğin, bir ikili arama gerçekleştirdiğimizde, her yapılan karşılaştırma, muhtemel cevapların sayısını 2 faktörü kadar azaltır. Olası en çok bir cevap kalana kadar, bu tekrarlanır. Bu nedenle, başlangıçta en fazla n + 1 olası cevap olduğunda ikili arama tarafından yapılan karşılaştırma sayısı en fazla [log2(n+1)] olarak hesaplanır. Bu kitapta birkaç kez ortaya çıkan başka bir logaritma türü de doğal logaritmadır. Burada loge k belirtimi için ln k gösterimi kullanılır. e – Euler sabiti – olarak aşağıda bildirilmiştir: Doğal logaritma sık sık gündeme gelmektedir, çünkü aşağıda verilen özellik ile ifade edildiği gibi, sıkça karşılaştığımız bir integralin değeridir: | 33 Logaritmalar ile en çok yaptığımız iki çalışmadan birincisi, onları bir üsse kaldırmaktır: İkincisi, logaritmanın tabanını değiştirmektir: Örneğin, doğal ve ikili logaritmayı karşılaştırmak için şu iki işlemi kullanabilirsiniz: 34| Faktöryeller Bu kitapta, bir veya iki yerde, faktöryel fonksiyonu kullanılmıştır. Negatif olmayan bir n tamsayısı için, n! (okunuşu "n faktöryel") gösterimi şöyle tanımlıdır: Faktöryellerin ortaya çıkmasına sebep, n farklı elemanın permütasyon sayısını, yani, sıralamasını saymaktır. Bu sonuç n! ile gösterilir. n = 0 özel durumu için, 0! = 1 olarak tanımlıdır. n! sayısı, Stirling'in Yaklaşımını kullanarak da, yaklaşık olarak tahmin edilir: Burada, Stirling'in Yaklaşımıyla, ln (n!) değeri de, yaklaşık olarak tahmin edilir: | 35 (Aslında, Stirling'in Yaklaşımı’na en kolay kanıt, ln (n!) = ln 1 + ln 2 + … + ln n ifadesinin değerini yaklaşık olarak integrali ile tahmin ederek verilir). Faktöryel fonksiyonu ile ilgili olarak iki terimli katsayılara değineceğiz. k Negatif olmayan bir tamsayı n, ve bir tamsayı {0,…,n} için şu gösterim doğru olarak hesaplanır: ile gösterilen iki terimli katsayının okunuşu, “n’in k tercihi” olarak telaffuz edilmelidir. n elemanlı bir kümenin, k elemanlı alt kümelerinin sayısını saymaya yarayan bu ifade, 1,…, n kümesinden k farklı tamsayıyı seçme yollarının sayısını verir. 36| Asimptotik Gösterim Bu kitapta veri yapılarını analiz ederken, çeşitli işlemlerin çalışma zamanları hakkında konuşmak istedik. Tam kesinlikteki çalışma zamanı, tabii ki, bilgisayardan bilgisayara ve hatta tek bir bilgisayar üzerindeki uygulamaları çalıştırmadan çalıştırmaya değişecektir. Bir işlemin çalışma zamanı hakkında konuştuğumuzda, işlem sırasında gerçekleştirilen bilgisayar komutlarının sayısına başvuruyoruz. Basit bir kod için bile, bu miktarı tam olarak hesaplamak zor olabilir. Bu nedenle, çalışma zamanlarını tam kesinlikte analiz etmek yerine, büyük-Oh adı verilen notasyonu kullanacağız: Bir f (n) fonksiyonu verildiğinde, O(f (n)) ile sınırlandırılmış bir fonksiyon kümesi şöyle tanımlanır: Grafiksel düşünüldüğünde, bu küme fonksiyonları, g(n) fonksiyonlarından oluşur; burada c f(n), n yeterince büyük olduğunda, g(n)’e başat olmaya başlar. Genellikle fonksiyonları kolaylaştırmak için asimptotik gösterim kullanılır. Örneğin, 5n log n + 8n – 200 yerine O (n lg n) yazılabilir ve şu şekilde kanıtlanabilir: | 37 Bu gösteriyor ki, 5n log n + 8n – 200 fonksiyonu c = 13 ve n0 = 2 için O (n lg n) kümesinin bir üyesidir. Asimptotik notasyonu kullanırken, bir dizi faydalı kısayollar uygulanabilir. Birincisi: Herhangi bir c1 < c2 için, İkincisi: Herhangi a, b, c > 0, sabit olmak şartıyla, Bu kapsama bağıntıları, herhangi bir pozitif değer ile çarpıldığında, hala geçerlidir. Örneğin, n ile çarpıldığında şu bağıntı elde edilir: Uzun ve seçkin bir geleneğin devamı olarak, bu notasyonu kötüye kullanarak, gerçekte f1(n) O(f(n)) demek yerine, f1(n)= O( f(n) ) yazabilirsiniz. Yine, “bu işlemin yürütme zamanı O(f (n))’dir.” gibi cümleler kurabilirsiniz. Gerçekte bu cümle “bu işlemin yürütme zamanı O(f (n))’in bir üyesidir.” olmalıdır. Bu kısayollar, çoğun- 38| lukla asimptotik notasyonu daha kolay denklem dizeleri içinde kullanmamızı sağlar. Aşağıdaki gibi ifadeler yazarken, özellikle garip bir örnek ortaya çıkar: Yine, bu daha doğru bir şekilde şöyle yazılmalıdır: O (1) ifadesi başka bir konuyu da gündeme getiriyor. Bu ifadede hiçbir değişken bulunmadığından, hangi değişkenin rasgele büyük olduğu açık olmayabilir. Bağlam olmadan bunu söylemenin hiçbir yolu yoktur. Yukarıdaki örnekte, denklemin geri kalanındaki tek değişken n olduğu için, denklemi şöyle okumamız gerektiğini varsayabiliriz: f(n) = 1 iken; T(n) = 2 log(n) + O (f(n)). Büyük-Oh notasyonu bilgisayar bilimleri için yeni ve benzersiz değildir. Sayı kuramcısı Paul Bachmann tarafından 1894 gibi erken bir tarihte kullanılmıştır ve bilgisayar algoritmalarının yürütme zamanlarını açıklamak için son derece yararlıdır. Aşağıdaki kod parçasını düşünün: | 39 Uygulanan bu yöntemin içerdiği işlemler şu listede sıralanmıştır: 1 atama (int i = 0), n + 1 karşılaştırma (i < n), n artırım (i ++), n bağıl konum dizi hesaplaması (a[i]), ve n dolaylı atama (a[i] = i). Bu yüzden, çalışma zamanını şöyle yazabiliriz: Burada a, b, c, d ve e, kodu çalıştıran makineye bağlı olan sabitlerdir, ve sırasıyla atamaları, karşılaştırmaları, artırım işlemlerini, bağıl konum dizi hesaplamalarını ve dolaylı atamaları gerçekleştirmek için gerekli zamanı gösterir. Bu ifade, iki satır kod çalışma zamanını gösterse de, açıkça bu tür bir analiz karmaşık kod veya algoritmalar için kolaylıkla işlenemeyecektir. Büyük-Oh notasyonunu kullanarak, çalışma zamanının basitleştirilmiş hali şöyledir: 40| Bu sadece daha küçük boyutlu olmakla kalmaz, ama aynı zamanda yaklaşık olarak aynı bilgiyi verir. Yukarıdaki örnekte, çalışma zamanının a, b, c, d ve e sabitlerine bağlı olması, genel olarak, sabit değerlerini bilmeksizin, iki çalışma zamanından hangisinin daha hızlı olduğunu bilmek ve bu amaçla karşılaştırma yapmanın da mümkün olamayacağı anlamına gelir. Sabit değerlerini belirlemek için (diyelim ki, zamanlama testleri aracılığıyla) çaba göstersek bile, sonuç sadece bizim üzerinde test yaptığımız makine için geçerli olacaktır. Büyük-Oh notasyonuyla daha karmaşık fonksiyonları çözümleyerek, çok daha yüksek düzeyde akıl ve mantık yürütebilir ve düşünebilirsiniz. Aynı büyük-Oh çalışma zamanına sahip iki algoritmanın, hangisinin daha hızlı olduğunu bilemezsiniz ve net bir kazanan olmayabilir. Biri tek makinede daha hızlı olabilir ve diğeri farklı bir makinede daha hızlı olabilir. Ancak, emin olabilirsiniz ki, iki algoritmanın kanıtlanabilir farkı, daha az büyük-Oh çalışma zamanı olan algoritmanın, yeterince büyük n değerleri için daha hızlı olacağıdır. Büyük-Oh notasyonu, iki farklı fonksiyonu karşılaştırmaveya olanak sağlar. Şekil 1.5’teki örnek, f1(n) = 15n ve f2(n)=2n log n fonksiyonlarının büyüme hızlarını karşılaştırıyor. Burada f1(n) karmaşık bir doğrusal zaman algoritmasının yürütme zamanı olabilir; f2(n) böl-ve-yönet paradigmasına dayanan oldukça daha basit bir algoritmanın çalışma zamanı olabilir. Bu örnek gösteriyor ki, küçük n değerleri için f1(n), f2(n)'den daha büyük olmasına rağmen, büyük | 41 n değerleri için tersi geçerlidir. Sonunda f1(n) giderek artan farkla kazanır. Büyük-Oh gösterimini kullanarak yapılan analiz, bunun böyle olacağını bize anlatmıştı, çünkü O (n) O (n log n) . Birkaç durumda, birden fazla değişkenli fonksiyonlar üzerinde de asimptotik gösterimi kullanacağız. Bunun için herhangi bir standart yoktur, ancak amaçlarımız için, aşağıdaki tanım yeterli olacaktır: Bu tanım, bizim gerçekten önem verdiğimiz koşulu, n1,…,nk argümanlarının g ’nin büyük değer almasını sağlaması durumunu yakalar. Bu tanım, aynı zamanda tek değişkenli O(f (n)) tanımı ile, f (n) n’in artan bir fonksiyonu olduğu zaman uzlaşır. Bizim amaçlarımız için bu kadarı yeterlidir, ancak okuyucu çok değişkenli fonksiyonlar ve farklı asimptotik gösterimlerin de ele alınabileceğini bilmelidir. 42| | 43 Rasgele Sıralama ve Olasılık Bu kitapta sunulan veri yapılarının bazıları rasgeleleştirilmiştir, depolanan veri değerlerinden veya üzerinde yapılan işlemlerden bağımsız olarak, rasgele seçimler yapar. Bu gibi yapıları kullandığınızda, aynı işlem kümesinin bir defadan fazla çalışmasıyla farklı yürütme zamanları oluşabilir. Analiz ederken, veri yapılarının ortalama veya beklenen çalışma süreleri ile ilgileniriz. Kurallı olarak, bir rasgele veri yapısı üzerindeki işlemin çalışma zamanı rasgele bir değişkendir ve beklenen değerini incelemek istiyoruz. Sonlu ve sayılabilir bir U uzayından değer alan, X ile tanımlı bir sonlu rasgele değişken için, X ’in beklenen değeri olan E [X] aşağıdaki formül ile verilmiştir: Burada olay ’nin meydana gelme olasılığını gösterir. Bu kitaptaki tüm örneklerde, bu olasılıklar yalnızca rasgeleleştirilmiş veri yapısı tarafından yapılan rasgele seçimler hakkındadır; ne veri yapısında depolanan verinin, ne de veri yapısı üzerinde gerçekleştirilen işlem sırasının, rasgele olduğuna dair bir varsayım yoktur. Beklenen değerlerin en önemli özelliklerinden biri, beklentinin doğrusallığıdır. Herhangi iki rasgele değişken, X ve Y için, 44| Daha genel olarak, herhangi bir rasgele değişken dizisi X1,…,Xk için, Beklentinin doğrusallığı, karmaşık rasgele değişkenleri (yukarıdaki denklemlerin sol tarafındakiler gibi), basit rasgele değişkenlerin bir toplamı halinde (sağ taraflar) bölmeye olanak sağlar. Tekrar tekrar kullanacağımız yararlı bir püf noktası, gösterge rasgele değişkenlerini tanımlamaktır. Bu ikili değişkenler, bir şeyi saymak istediğimizde yararlıdır; açıklayıcı en iyi bir örnek şöyle verilir. Bir bozuk parayı k defa hilesiz fırlattığımızı varsayalım, para yere düşünce kaç kez tura gelmesinin beklenen sayısını bilmek istiyoruz. Sezgisel olarak, cevabın k/2 olduğunu biliyoruz, ancak değer beklentisi tanımını kullanarak bunu kanıtlamaya çalışırsak, | 45 Burada, olasılığını hesaplamayı ve ve ikili özdeşliklerini yeterince bilmeniz gereklidir. Gösterge değişkenlerini ve beklentinin doğrusallığı ilkesini kullanarak işler çok daha kolay hale gelir. Her i ge rasgele değişkeni tanımlayalım: O zaman, Şimdi, , bu nedenle, 1,…,k için, göster- 46| Sözü biraz uzattık, ancak herhangi bir sihirli özdeşliği bilmemizi veya herhangi bir kayda değer olasılık hesabını gerektirmiyor. Daha da iyisi, paraların tam olarak yarısının tura geleceği sezgisi ile uyumludur, çünkü her para 1/2 olasılık ile tura olarak ortaya çıkıyor. | 47 Hesaplama Modeli Bu kitapta, çalıştığımız veri yapıları üzerindeki işlemlerin teorik çalışma sürelerini analiz edeceğiz. Tam olarak bunu yapmak için, bir matematiksel hesaplama modeli gereklidir. Bunun için, w-bit sözcük-RAM modelini kullanacağız. RAM Rasgele Erişimli Makine’ye denk gelir. Bu modelde, her biri w-bit sözcük depolayan hücrelerden oluşan bir rasgele erişimli belleğe erişimimiz vardır. Bu demektir ki, bir bellek hücresi, örneğin, kümesin- den bir tamsayıyı gösterebilir. Sözcük-RAM modelinde, sözcükler üzerindeki temel işlemler sabit zaman alır. Aritmetik işlemleri , karşılaştırmaları , ve bitsel-Boole işlemlerini içerir (bit-bit-VE, VEYA, ve dışlayıcı-VEYA). Herhangi bir hücre, sabit zamanda okunabilir veya yazılabilir. Bir bilgisayarın belleği, istediğimiz herhangi büyüklükte bir bellek bloğunun tahsis edilmesini veya serbest bırakılmasını sağlayacak bir bellek yönetim sistemi tarafından yönetilmektedir. k boyutunda bir bellek bloğunu tahsis etmek, O(k) zaman alır ve yeni ayrılan bellek bloğu için bir işaretçi döndürür. Bu işaretçi, bir tek sözcük ile temsil edilebilecek kadar küçüktür. Sözcük-boyutu, w, bu modelin çok önemli bir parametresidir. w hakkında yapılacak tek varsayım alt sınır olmuştur, bu- 48| rada n herhangi bir veri yapısında depolanan elemanların sayısıdır. Bu oldukça orta halli bir varsayımdır, aksi takdirde bir veri yapısında depolanan elemanların sayısını saymak için bile sözcük yeterince büyük olmayacaktır. Alan, bellek sözcüğü ile ölçülür, bir veri yapısı tarafından kullanılan alan miktarından bahsederken, kullanılan bellek sözcüğü sayısı ile ilgilenmeliyiz. Veri yapılarınızın tamamı, bir genelleyici tür olan T değeri ile tanımlı olabilir, ve T türü bir elemanın belleğin bir sözcüğünü kapladığını varsayabilirsiniz (gerçekte, T türü nesnelere referansları depoluyoruz, ve bu referanslar bellekte sadece bir sözcük kaplıyor). 32-bit Java Sanal Makinesi (JVM) için, w-bit sözcük-RAM modeli, w=32 olduğunda, oldukça uygundur. Bu kitapta sunulan veri yapıları, JVM ve çoğu diğer mimari üzerinde uygulanamaz özellikte yaklaşımlar kullanmamaktadır. | 49 Doğruluk, Zaman Karmaşıklığı ve Alan Karmaşıklığı Bir veri yapısının performansını incelerken, en önemli üç konu vardır: Doğruluk: Veri yapısı doğru şekilde arayüzünü uygulamalıdır. Zaman karmaşıklığı: Veri yapısı üzerindeki işlemlerin çalışma süreleri mümkün olduğunca küçük olmalıdır. Alan karmaşıklığı: Veri yapısı mümkün olduğunca az bellek kullanmalıdır. Bu giriş bölümünde, doğruluk veriliyor kabul edeceğiz; sorgulara hatalı yanıtlar veren veya düzgün güncelleme yapmayan veri yapılarını dikkate almayacağız. Ancak, en az alan kullanımını çalıştırmak için ekstra bir çaba gösteren veri yapılarını göreceksiniz. Bu, genellikle işlemlerin (asimptotik) yürütme sürelerini etkilemez, ancak pratikte veri yapılarını biraz daha yavaşlatabilir. Veri yapılarının çalışma sürelerini incelerken, üç farklı tür çalışma zamanı eğilimi ile karşılaşırız: En-kötü durum çalışma zamanı: Bunlar çalışma zamanı garantilerinin en güçlü türüdür. Veri yapısı f(n) en-kötü durum çalışma 50| zamanıne sahipse, o zaman her bir işlemin çalışma zamanı f(n)’den asla daha uzun zaman almaz. Amortize çalışma zamanı: Veri yapısı içindeki bir işlemin amortize çalışma zamanının f(n) olduğunu söylemek demek, tipik bir işlem maliyetinin en fazla f(n) olduğu anlamına gelir. Daha kesin olarak, bir veri yapısı f(n) amortize çalışma zamanına sahipse, bir dizi m işlemi en fazla m f(n) zamanda çalışır. Bazı işlemler bireysel olarak f(n)’den daha fazla sürebilir, ancak işlemlerin bütün dizisi için, ortalama, en fazla f(n)’dir. Beklenen çalışma zamanı: Veri yapısı üzerinde bir işlemin beklenen çalışma zamanınin f(n) olduğunu söylediğimizde, bu gerçek çalışma zamanının bir rasgele değişken (bkz. Rasgele Sıralama ve Olasılık Bölümü) olduğu ve bu rasgele değişkenin beklenen değerinin en fazla f(n) olduğu anlamına gelir. Buradaki rasgelelik veri yapısı tarafından yapılan rasgele seçimler ile ilgilidir. En-kötü durum, amortize ve beklenen çalışma zamanları arasındaki farkı anlamak için bir mali örneği düşünmek yardımcı olarak hesaplanır. Bir ev satın alma maliyetini düşünün: En-kötü durum’a karşılık amortize maliyet: Bir ev maliyetinin 120.000$ olduğunu varsayalım. Bu evi satın almak için, 1.200$ aylık ödemeler ile 120 aylık (10 yıl) ipotek alabiliriz. Bu durumda, bu ipoteğin ödeme maliyeti en-kötü durumda aylık 1.200$ olarak hesaplanır. | 51 Elimizde yeterli para varsa, 120.000$ bir ödeme ile evi doğrudan satın almayı seçebiliriz. Bu durumda, 10 yıllık bir süre içinde, bu evi satın almanın amortize edilmiş aylık maliyeti 120.000$ / 120 ay = 1.000$ aylık . Bunun anlamı, eğer ipoteği ödemek zorunda kalsaydık ayda 1.200$’dan daha azdır. En-kötü durum’a karşılık beklenen maliyet: Şimdi, bizim 120.000$ ’lık evimizde, yangın sigortası sorununu dikkate alalım. Yüzbinlerce olayı inceleyen sigorta şirketleri, bizimki gibi bir evde beklenen aylık yangın hasar miktarının 10$ olduğunu belirlediler. Bu çok küçük bir sayıdır, çünkü pek çok evde asla yangın çıkmaz, birkaç evde biraz duman hasarı yaratan bazı küçük yangınlar olabilir, ve evlerin pek azı büyük yangın geçirir. Bu bilgilere dayanarak, sigorta şirketi yangın sigortası için 15$ aylık ücret talep eder. Şimdi karar zamanı. Yangın sigortası için en-kötü durumda 15$ aylık maliyeti ödemeli miyiz, veya risk alıp ayda 10$ beklenen maliyet pahasına kendi kendimizi sigortalamamız mı gerekir? Açıkçası, beklentide aylık 10$ daha az masraf yapıyor, ama biz gerçek maliyetin çok daha yüksek olabileceği olasılığını kabul etmek zorundayız. Bütün evin yanması olası durumunda, gerçek maliyet 120.000$ olacaktır. 52| Bu finansal örnekler neden bazen en-kötü durumda çalışan zaman yerine amortize edilmiş veya beklenen çalışma zamanı ile yetindiğimize dair bize ışık tutuyor. Çoğunlukla en-kötü zamandan daha düşük bir beklenen veya amortize zaman elde etmek mümkündür. En azından, amortize veya beklenen çalışma süreleriyle yetinmeye istekli bir kimsenin çok daha basit bir veri yapısı elde etmesi çoğu kez mümkündür. | 53 Kod Örnekleri Bu kitaptaki kod örnekleri, Java programlama dilinde yazılmıştır. Ancak, Java'nın yapıları ve anahtar sözcüklerinin tümüne aşina olmayan okuyuculara kitabı erişilebilir hale getirmek için, kod örnekleri basitleştirilmiştir. Örneğin, bir okuyucu, public, protected, private veya static gibi anahtar sözcüklerden hiçbirini bulamaya- caktır. Okuyucu, aynı zamanda sınıf hiyerarşileri hakkında da fazla tartışma bulamayacaktır. Belirli bir sınıfın hangi arayüzleri uyguladığı veya hangi sınıfı genişlettiği, eğer tartışma ile ilgiliyse, ilişikteki metinden açık olmalıdır. Böylece, B, C, C++, C#, Objective-C, D, Java, JavaScript dahil, ALGOL geleneğinden gelen herhangi bir dilin birikimine sahip olan herkes tarafından kod örnekleri anlaşılabilir hale gelmiştir. Tüm uygulamaların bütün ayrıntılarını isteyen okuyucular, bu kitaba eşlik eden Java kaynak koduna bakabilir. Bu kitapta analiz edilen algoritmalar için çalışma zamanlarının matematiksel analizleri ile Java kaynak kodu karışık halde bulunmaktadır. Bunun anlamı, bazı denklemler kaynak kodunda da bulunan değişkenleri içermektedir. Bu değişkenler, hem kaynak kodu içinde ve hem denklem içinde sürekli görünür. Bu tür değişkenlerin en çok kullanılanı, istisnasız olarak, her veri yapısında depolanan eleman sayısına karşılık gelen n’dir. 54| Veri Yapıları Listesi Tablo 1.1 ve 1.2, bu kitapta Arayüzler Bölümü'nde anlatılan Liste, UKüme ve SKüme arayüzlerini gerçekleştiren veri yapılarının per- formansını özetliyor. | 55 56| Tartışma ve Alıştırmalar Arayüzler Bölümü’nde açıklanan Liste, UKüme ve SKüme arayüzleri Java Koleksiyonları Çerçevesi [54] tarafından etkilenmiştir. Bunlar Java Koleksiyonlar Çerçevesinde bulunan List, Set, Map, SortedSet ve SortedMap arayüzlerinin esas olarak basitleşti- rilmiş versiyonlarıdır. İlişikteki kaynak kod, Set, Map, SortedSet ve SortedMap uygulamaları içine UKüme ve SKüme uygulamalarını yerleştirmek için gerekli sarmalayıcı sınıfları içerir. Bu bölümde tartışılan matematik, asimptotik gösterim, logaritma, faktöriyel, Stirling yaklaşımı, temel olasılık ve daha fazlası dahil olmak üzere mükemmel (ve serbest) bir şekilde Leyman, Leighton, ve Meyer [50] tarafından ele alınmıştır. Üssel ve logaritmaların biçimsel tanımlarını içeren ılımlı bir hesap kitabı için ise, Thompson [73] tarafından kaleme alınmış (serbestçe kullanılabilir) klasik kitaba başvurunuz. Özellikle bilgisayar bilimleri ile ilgili olarak temel olasılık hakkında daha fazla bilgi için, Ross [65] tarafından yazılmış ders kitabına bakmanız önerilir. Asimptotik gösterim ve olasılığı kapsayan bir başka iyi referans da, Graham, Knuth ve Patashnik tarafından yazılan ders kitabıdır [37]. Kendi Java programlamalarını gözden geçirmek isteyen okuyucular etkileşimli pek çok Java eğitimlerini bulabilirler [56]. | 57 Alıştırma 1.1. Bu alıştırma, doğru problem için doğru veri yapısı seçimini okuyucuya tanıtmaya yardımcı olmak için tasarlanmıştır. Gerçekleştirilirse, bu alıştırmanın bölümleri Java Koleksiyonları Çerçevesi tarafından sağlanan ilgili arayüzün (Yığıt, Kuyruk, İki Başlı Kuyruk, UKüme veya SKüme) bir uygulamasından yararlana- rak yapılmalıdır. Aşağıdaki problemleri bir metin dosyasını her seferde bir satır okuyarak, ve her satır için işlemleri uygun veri yapı(ları) içinde gerçekleştirerek çözün. Uygulamalarınız, bir milyon satır içeren dosyaları bile birkaç saniye içinde işleyebilecek kadar hızlı olmalıdır. 1. Girdiyi bir seferde bir satır olmak üzere okuyun ve daha sonra ters sırayla satırları yazın. Son giriş satırı ilk olarak yazılacaktır; daha sonra sondan ikinci giriş satırı yazılacaktır, vb. 2. Girdinin ilk 50 satırını okuyun ve daha sonra bunları ters sıray- la yazın. Sonraki 50 satırı okuyun ve daha sonra ters sırayla bunları yazın. Bunu okumak için artık satır kalmayana dek devam ettirin. Bu noktada kalan satırlar ters sırayla çıktıya yazılmalıdır. Diğer bir deyişle, çıktınız ilk satırda 50. satır, sonra 49. satır, sonra 48.satır ile başlayacak ve bu böyle 1. satıra kadar devam edecektir. Bunu takiben, 100.satır, sonra 99. satır yazılacak ve bu böyle 51. satıra kadar devam edecektir, vb. Kodunuz, herhangi bir zamanda, asla 50 satırdan fazla depolamak zorunda değildir. 3. Her seferde bir girdi satırı okuyun. İlk 42 satırı okuduktan son- ra herhangi bir noktada, eğer bazı satırlar boşsa (yani, 0 uzunlu- 58| ğunda bir dize) ondan 42 satır öncesindeki satırı çıktı olarak yazın. Örneğin 242. satır boş ise, programın çıktısı 200.satır olmalıdır. Bu program, herhangi bir zamanda, 43 satırdan fazla girdi depolamayacak şekilde uygulanmalıdır. 4. Her seferde bir girdi satırı okuyun ve her satırı, önceki giriş satırlarında yinelenmediyse çıktıya yazın. Çok fazla yinelenen satır içeren bir dosyanın tekil satır sayısı için gerekli olandan daha fazla bellek kullanmaması gerektiğine özellikle dikkat edin. 5. Her seferde bir girdi satırı okuyun ve bu satırı daha önce zaten okuduysanız çıktıya yazın (sonuçta, her satır ilk geçtiği yerden silinecektir). Çok fazla yinelenen satır içeren bir dosyanın tekil satır sayısı için gerekli olandan daha fazla bellek kullanmaması gerektiğine özellikle dikkat edin. 6. Tüm girdiyi, her seferde bir satır olacak şekilde okuyun. Sonra, uzunluğuna göre sıralanmış tüm satırları, kısa satırlar önce olmak üzere çıktıya yazın. İki satırın aynı uzunluğa sahip olması durumunda, her zamanki “sıralama ölçütünü” kullanarak sıralarını çözümleyin. Yinelenen satırlar sadece bir kez yazılmalıdır. 7. Önceki soruda istenenin aynısını yapın; yalnız bu sefer yinele- nen satırlar, girdide göründükleri satır sayısı kadar çıktıda yazılmış olmalıdır. 8. Her seferde bir girdi satırı okuyun ve çift sayılı satırları (0. satır ile başlayan ilk satır ile) çıktıya yazın; daha sonra tek sayılı satırları yazın. 9. Tüm girdiyi her seferde bir satır olacak şekilde okuyun ve sa- tırları çıktıya yazmadan önce rasgele permütasyon yapın. Anlaşılır olmak gerekirse, herhangi bir satırın içeriğini değiştirmemeniz ge- | 59 rekir. Bunun yerine, aynı satır topluluğunu yazdırmalısınız, ancak rasgele sırayla yapılmalıdır. Alıştırma 1.2. Dyck sözcüğü, +1 ve 1’lerden oluşur ve dizinin herhangi bir önek toplamının negatif olmaması şartı aranır. Örneğin +1, 1, +1, 1 Dyck sözcüğüdür, ancak +1, 1, 1, +1 değildir, çünkü önek +1 1 – 1 0. Dyck sözcüğü ve Yığıt işlemlerinden yığ(x) ve sil() arasındaki herhangi bir ilişkiyi açıklayın. Alıştırma 1.3. Uyumlu dize, düzgün eşleştirilen {, },(, ),[, ] karakterlerinden oluşan bir dizedir. Örneğin, “{{()[]}}” bir uyumlu dizedir, ancak “{{()]}” değildir, çünkü ikinci { eşleşmesi ] ile olmuştur. n uzunluğunda bir dize verildiğinde, bunun uyumlu dize olup ol- madığını kontrol etmek için O(n) zamanında çalışan bir yığıttan nasıl faydalanılabileceğini gösterin. Alıştırma 1.4. Sadece yığ(x) ve sil() işlemlerini destekleyen bir Yığıt, s, olduğunu varsayalım. Sadece bir FIFO Kuyruk, q, kullana- rak nasıl tüm elemanların sırasını tersine çevirebileceğinizi gösterin. Alıştırma 1.5. Bir UKüme kullanarak, Torba arayüzünü uygulayınız. Torba, UKüme gibidir ekle(x), sil(x) ve bul(x) işlemlerini destekler ancak, yinelenen elemanların depolanmasını da sağlar. Torba’daki bul(x) işlemi, herhangi x elemanı (varsa) döndürür. Buna ek olarak, Torba, x’e eşit olan tüm elemanların bir listesini döndüren hepsiniBul(x) işlemini destekler. 60| Alıştırma 1.6. Liste, UKüme ve SKüme arayüzlerinin uygulamalarını sıfırdan yazın ve test edin. Bunların verimli olması gerekmez (bunu yapmanın en kolay yolu, elemanları bir dizide depolamaktır). Bu uygulamaları, daha verimli olanların doğruluğunu ve performansını test etmek için daha sonra kullanabilirsiniz. Alıştırma 1.7. Önceki alıştırmada yazdığınız uygulamaların performansını artırmak için, aklınıza gelebilecek herhangi bir püf noktasını kullanarak çalışın. Liste uygulamasında, ekle(i, x) ve sil(i) işlemlerinin performansını nasıl artıracağınızı düşünün ve deneyin. UKüme ve SKüme uygulamalarında bul(x, i) işleminin performan- sını artırmayı düşünün. Bu alıştırma, size, bu arayüzlerin verimli uygulamalarını elde etmenin ne kadar zor olabileceğine dair fikir vermek için tasarlanmıştır. | 61 Bölüm 2 Dizi-Tabanlı Listeler Bu bölümde, Liste ve Kuyruk arayüzü uygulamalarını öğreneceğiz. Bu uygulamaların belli başlı verileri, takviye dizi adı verilen bir dizide depolanmıştır. Bu bölümde sunulan veri yapılarının temel işlemleri aşağıdaki tabloda verilen çalışma zamanlarıyla özetlenmiştir: Sadece bir tek diziye veri depolayan veri yapıları için birçok avantaj ve sınırlamalar bulunmaktadır: Herhangi bir değere sabit zamanlı erişim sunmak için diziler yeterlidir. al(i) ve belirle(, x) işlemleri sabit zamanda çalışır. Dinamik olma özelliği aranmadığı için, dizinin ortasına yakın bir konumuna eleman eklenmesi veya silinmesi, çok sayıda kaydırma hareketinin hesaplanmasına neden olur. Dizinin alan boşluğunu iyi değerlendirmek için, çok sayıda elemanın yeni eklenen elemana yer açması veya silinen eleman tarafından yaratılan boşlu- 62| ğu doldurması gerekir. Bu nedenle ekle(i, x) ve sil(i) işlemlerinin çalışma süreleri, n ve i’ye bağlıdır. Dizileri genişletmek veya küçültmek çoğu zaman mümkün değildir. Veri yapısında bulunan eleman sayısı, takviye dizinin boyutunu aşarsa, yeni bir dizinin tahsis edilmesi ve eski diziye ait verilerin yeni diziye kopyalanması gerekir. Bunu gerçekleştirmek pahalı bir işlemdir. Üçüncü nokta önemlidir. Yukarıdaki tabloda belirttiğimiz çalışma süreleri içinde, takviye dizinin büyümesi ve küçülmesi ile ilişkili maliyetleri dahil etmedik. Ancak dikkatli uygulandığı takdirde, takviye dizinin büyümesi ve küçülmesiyle birlikte gelen maliyetin, ortalama bir işlem maliyetinden fazla olmadığını görürüz. Daha doğrusu, boş bir veri yapısı ile başladığınızda, herhangi bir sırada m adet ekle(i, x) ve sil(i) işlemi çalıştırılırsa, takviye diziyi büyültüp, küçültmenin tüm bu m işlem sırasındaki maliyeti O(m) olarak hesaplanır. Birbirinden ayrı bazı işlemler daha pahalı olmasına rağmen, m adet işlemin tümü üstünden amortize maliyet hesaplandığı takdirde, her işlem için sadece O(1) çalışma zamanı vardır. | 63 Dizi Yığıtı: Dizi Kullanan Hızlı Yığıt İşlemleri Dizi Yığıtı, liste arayüzünü, a, takviye dizisini kullanarak uygulama- ya koymuştur. i konumunda bulunan liste elemanı a[i] içinde depolanmaktadır. Çoğu zaman, a boyutunu tam olarak gerekli olduğundan daha büyük olarak belirleyebiliriz, bu nedenle, a dizisinde herhangi bir anda depolanan elemanların sayısını tutan n tamsayısını kullanırız. Listenin elemanları a[0],…,a[n-1] içinde depolanmışken, her zaman için a.boyut n koşulu geçerlidir. 64| Temel Bilgiler Dizi Yığıtı le(i, x) elemanlarına erişmek ve değiştirmek için al(i) ve belir- işlemlerini gerçekleştiririz; bu kolay anlaşılırdır. Gerekli sınır denetimini yaptıktan sonra geriye sadece, sırasıyla, a[i] değeri döndürmek veya değiştirmek kalır. Dizi Yığıtı’na eleman ekleme ve kaldırma işlemlerinin örnek çalış- tırmaları Şekil 2.1’de gösterilmiştir. ekle(i, x) işlemini gerçekleştirmek için, ilk olarak, a dizisinin halen dolu olup olmadığını kontrol ederiz. Eğer öyleyse, a’nın boyutunu artırmak için yeniden_boyutlandır() işlemini çağırırız. yeniden_boyutlandır() işle- minin nasıl gerçekleştirildiğini daha sonra ele alacağız. Şimdilik, yeniden_boyutlandır() emin olmak çağrısından sonra, a.boyut > n olduğundan yeterlidir. Bu arada, x’e yer açmak için elemanlarını bir konum sağa kaydırıyoruz, sonra a[i] elemanını x değerine eşitliyoruz ve n değerini 1 artırıyoruz. | 65 yeniden_boyutlandır() işlemi için yapılan potansiyel çağrı maliyeti önemsenmediği takdirde, ekle(i, x) işleminin maliyeti, x’e yer açmak için kaydırılması gereken eleman sayısı ile orantılıdır. Bu nedenle, kaydırma hareketlerinin çalışma maliyeti (boyutlandırma maliyeti önemsenmediği takdirde), O(n – i + 1) olarak hesaplanır. sil(i) işlemini uygulamak benzer şekilde gerçekleşir. elemanlarını bir konum sola kaydırırız (a[i] üzerine yazarak), ve n değerini 1 azaltırız. Sonra, a.length 3n koşulunu test ederek, n değerinin a.length uzunluğundan azımsanmayacak kadar küçük olup olmadığını kontrol ediyoruz. Eğer öyleyse, a’nın boyutunu azaltmak için yeniden_boyutlandır() işlemini çağırıyoruz. 66| yeniden_boyutlandır() sil(i) işleminin maliyeti önemsenmediği takdirde, işleminin çalışma maliyeti, kaydırılan elemanların sayısı ile orantılı, O(n i) olarak hesaplanır. | 67 Büyültme ve Küçültme yeniden_boyutlandır() işlemi yeterince anlaşılırdır; boyutu 2n olan yeni bir b dizisi tahsis eder, b’nin ilk n pozisyonuna n elemanı kopyalar, ve daha sonra a’yı b’ye belirler. Böylece bir yeniden_boyutlandır() çağrısından sonra a.length=2n olarak hesap- lanır. yeniden_boyutlandır() işleminin gerçek maliyetini analiz etmek kolaydır. 2n boyutuna sahip olan, b dizisini bellekten tahsis eder, ve n elemanı b içine kopyalar. O(n) çalışma zamanı vardır. Önceki bölümde yaptığımız çalışma zamanı analizinde, yeniden boyutlandırmak için yapılan çağrıların maliyetini önemsememiştik. Amortize analiz diye bilinen bir tekniği kullanarak maliyet analizine devam edeceğiz. Bu teknik, her ekle(i, x) ve sil(i) işlemi sırasında gerçekleştirilen yeniden boyutlandırma maliyetini hesaplamaz. ekle(i, x) ve sil (i) işlemlerinin m defa çağrılması sırasında, yeniden boyutlandırmak için yapılan tüm çağrıların maliyetini çözer. Bu bölümde özellikle şunu göstereceğiz: 68| Öneri 2.1: Başlangıçta Dizi Liste elemanları boş iken, ekle(i, x) ve sil(i) işlemleri sıralı olarak m den_boyutlandır() 1 defa çağrılırsa, o zaman yeni- için yapılan tüm çağrılar sırasında harcanan toplam zaman O(m) olarak hesaplanır. Kanıt: yeniden_boyutlandır() işlemi her çağrıldığında, son çağrıdan bu yana gerçekleştirilen ekle veya sil işlem sayısının en az n/2-1 olduğunu göstereceğiz. Bu nedenle, yeniden_boyutlandır() için yapılan i'inci çağrı sırasındaki n değeri ni ile, ve yeniden_boyutlandır() toplam çağrı sayısı r ile gösterilirse, ekle(i, x) veya sil(i) için yapılan toplam çağrı sayısı en az, olarak yazılır, ve şuna eşittir: Öte yandan, yeniden_boyutlandır() için yapılan tüm aramalar sırasında harcanan toplam zaman, r değeri m’den fazla olmadığından, olarak belirlenir. Geriye kalan tek yapmamız gereken, yeniden_boyutlandır() için gerçekleştirilen (i – 1)’inci ve i’inci arama- | 69 lar arasında yapılan ekle(i, x) veya sil(i) çağrı sayısının en az ni / 2 olduğunu göstermektir. Dikkate alınması gereken iki durum vardır. Birinci durumda, takviye dizisi, a, dolu olduğundan ekle(i, x) tarafından yeniden_boyutlandır() çağrılıyor. Bu durumda, a.length n ni ol- muştur. Yeniden boyutlandırmak için yapılan bir önceki çağrıyı düşünün: Bir önceki çağrıdan sonra, a’nın uzunluğu a.length, ve a içinde depolanmış elemanların sayısı en fazla a.length/2 = ni /2 olarak hesaplanır. Fakat şimdi, a, içinde depolanmış elemanların sayısı ni = a.length olup, bir önceki yeniden_boyutlandır() çağrısından bu yana, ekle(i, x) işlemi için en az ni /2 çağrı yapılmıştır. İkinci durumda, yeniden_boyutlandır() çağrısı, sil(i) tarafından yapılmıştır, bu durumda a.length 3n = 3ni olduğunu düşünme- liyiz. Yeniden boyutlandırmak için yapılan bir önceki çağrıdan sonra, a içinde depolanmış elemanların sayısı en az a.length/2 olmuştur. ni Şu anda, a.length/3 a içinde depolanmış eleman 1 sayısı kadar olduğu için, yeniden boyutlandırmak için yapılan en son çağrıdan bu yana, gerekli sil(i) işlem sayısı en az olarak, 70| Her iki durumda da, yeniden_boyutlandır() için yapılan (i – 1)’inci ve i’inci aramalar sırasında ekle(i, x), veya sil(i) için yapılan çağrı sayısı en az ni / 2 1 olmuştur. | 71 Özet Aşağıdaki teorem Dizi Yığıt’ının performansını özetlemektedir: Teorem 2.1. Dizi den_boyutlandır() Yığıt, Liste arayüzünü uygular. yeni- için yapılan işlem çağrısının maliyeti önem- senmediği takdirde, Dizi Yığıt şu işlemleri destekler: al(i) ekle(i, x) ve belirle(i, x) işlem başına O(1) zamanda çalışır, ve sil(i) işlem başına O(1 + n - i) zamanda çalışır. Başlangıçta, Dizi Yığıt elemanları boş değer taşırken, ve ekle(i, x) ve sil(i) işlemleri sıralı olarak m defa çağrılırsa, yeni- den_boyutlandır() işlemi için yapılan tüm çağrılar O(m) toplam zamanda çalışır. Dizi Yığıt uygulaması, Yığıt arayüzünü gerçekleştirmek için etkili bir yoldur. Özellikle, yığ(x) işlemini ekle(n, x) çağrısı ile gerçekleştirebiliriz. sil(x) işlemini gerçekleştirmek için sil(n - 1) çağrısı yaparız. Bu işlemler, O(1) amortize zamanda çalışır. 72| Hızlı Dizi Yığıtı: Optimize Dizi Yığıtı Dizi Yığıtı tarafından yerine getirilen görevlerin çoğu, veri karşılaş- tırmak (ekle(n, x) ve sil(x) tarafından gerçekleşir) ve kopyalamaktır (yeniden_boyutlandır() tarafından gerçekleşir). Yukarıda gösterilen uygulamalarda, for döngüleri içinde bunu uyguladık. Oysa ki, birçok programlama ortamlarının veri bloklarını kopyalama ve taşıma konusunda çok verimli olan özel işlevlere sahip olduğu ortaya çıkmıştır. C programlama memmove(d, s, n) a1, b) dilinde memcpy(d, s, n) ve fonksiyonları vardır. C++ içinde std::copy(a0, algoritması vardır. Java’da System:arraycopy (s, i, d, j, n) metotu vardır. | 73 Bu fonksiyonlar genellikle oldukça optimize edilmiştir ve hatta for döngüsü kullanarak yapabileceğimiz kopyalamadan çok daha hızlı özel makine komutlarını kullanır. Bu işlevleri kullanarak asimptotik çalışma saatlerini azaltmak mümkün olmasa da, hala değerli birer optimizasyon sayılabilir. Buradaki Java uygulamalarında, System.arraycopy(s, i, d, j, n) çağrısıyla, işlem türüne bağlı ola- rak 2 ila 3 faktör arasındaki hız artışları kaydedilmiştir. Sizin ölçümleriniz değişiklik gösterebilir. 74| Dizi Kuyruğu: Dizi-Tabanlı Kuyruk Bu bölümde, FIFO (ilk-giren-ilk-çıkar) Kuyruğu’nu uygulayan Dizi Kuyruğu veri yapısını sunacağız. Elemanlar (ekle() işlemi ile ger- çekleşen), eklendikleri sırada silinir (silme işlemi sil() çağrısı ile gerçekleşir). Dizi Kuyruğu’nun, FIFO Kuyruğu’nu uygulamak için kötü bir se- çim olduğuna dikkat edin. İyi bir seçim değildir, çünkü elemanları eklemek için, önce listenin bir ucunu seçmeliyiz ve daha sonra listenin diğer ucundan elemanları silmeliyiz. İki işlemden birinin listenin başında, i = 0 değerindeyken, çalışması gereklidir. Ekle(x, i) veya sil(i) işlemi için yapılan çağrının çalışma zamanı, eleman sayısı, n ile orantılıdır. Dizi-tabanlı uygulamadan verim elde etmek için öncelikle sonsuz bir, a, dizisi olsaydı, sorun kolaylıkla çözülebilirdi. j endeksi bir sonraki silinecek elemanın konumunu, ve n tamsayısı kuyruktaki eleman sayısını tutsun. Kuyruk elemanları, her zaman için şu konumlarda bulunacaktır: Başlangıçta, j endeksi ve n tamsayısı da 0 ile başlamıştır. Bir elemanı eklemek için a[j + n] konumuna yerleştiririz, ve n değerini 1 | 75 artırırız. Bir elemanı silmek için, a[j] konumundan kaldırırız, j değerini 1 artırırız, ve n değerini 1 azaltırız. Tabii ki, bu çözümdeki sorun, sonsuz bir dizi gerektirmesidir. Dizi Yığıtı sonlu bir, a, dizisini ve modüler aritmetik kullanarak, bu çö- züm yoluna benzetim yapar. Günün zamanı hakkında konuştuğumuzda kullandığımız aritmetik türü modüler aritmetiktir. Örneğin, saat 10:00’dan başlayarak beş saat ileri gittiğinizde saat 03:00 elde edilir. Biçimsel olarak demek istiyoruz ki, Bu denklemin ikinci bölümü “15 modülo 12 denktir 3” şeklinde okunur. İkili işleç mod olarak da ele alınabilir; şöyle ki, Daha genel olarak, bir a tamsayısı ve pozitif bir m tamsayısı için, a mod m benzersiz bir r tamsayısına denktir, öyle ki ve herhangi bir k tamsayısı için a = r + km eşitliği sağlanmalıdır. Daha az biçimsel olarak hesaplarsak, r değeri a, m’e bölündüğünde ortaya çıkan kalandır. Java gibi birçok programlama dilinde, mod işleci % simgesi ile gösterilir. Modüler aritmetik sonsuz bir diziye benzetim yapmak için yararlıdır, çünkü i mod a.length her zaman 0,…,a.length 1 aralığında 76| bir değer verir. Modüler aritmetik kullanarak kuyruk elemanlarını aşağıdaki dizi konumlarında depolayabiliriz: Burada a dizisi bir dairesel dizi gibi değerlendirilmiştir. a.length 1’den daha büyük olan dizi endeksleri, dizinin başlangıcına doğru "sarar". Endişelenmesi ve dikkat edilmesi gereken tek şart, Dizi Kuyruk içinde bulunan eleman sayısı, takviye dizisi olan a’nın boyutunu aşmamalıdır. Dizi Kuyruk işlemlerinden ekle(x) ve sil() çalıştırmaları için birer örnek Şekil 2.2'de gösterilmiştir. ekle(x) işlemini gerçekleştirmek için, öncelikle a’nın dolu olup olmadığını kontrol ederiz, ve gerekirse, a’nın boyutunu artırmak için yeniden_boyutlandır() işlem çağrısı yaparız. a[(j + n) % a.length] konumunda x değerini belirledikten sonra, n değerini 1 artırırız. | 77 sil() işlemini gerçekleştirmek için öncelikle, a[j] elemanına daha sonra geri dönmek üzere, yedeğini alırız. n değerini 1 azaltırız ve j = (j + 1) mod a.length belirlemesiyle, j mod (a.length) değerini 1 artırırız. a[j] konumunda önceden depolamış olduğumuz değeri işlem sonucu olarak döndürürüz, ve gerekiyorsa, a boyutunu azaltmak için yeniden_boyutlandır() işlemini çağırırız. Son olarak, yeniden_boyutlandır() işlemi Dizi Yığıt içinde çalışan yeniden boyutlandırmaya çok benzer. Boyutu 2n olan, yeni bir b dizisi tahsis eder, ve aşağıdaki elemanları, 78| yeni dizi elemanlarının üzerine yazar: ve j = 0 olarak belirler. | 79 Özet Aşağıdaki teorem Dizi Kuyruk veri yapısının performansını özetlemektedir: Teorem 2.2. Dizi Kuyruk veri yapısı, (FIFO) Kuyruk arayüzünü uygular. yeniden_boyutlandır() için yapılan işlem çağrısı maliyeti önemsenmediği takdirde, Dizi Kuyruk işlemlerinden ekle(x) ve sil() O(1) zamanda çalışır. Başlangıçta, Dizi Kuyruk elemanları boş değer taşırken, ekle (i, x) ve sil (i) işlemleri sıralı olarak m defa çağrılırsa, yeniden_boyutlandır() işlemi için yapılan tüm çağrılar, O(m) toplam zamanda çalışır. 80| Dizi İki Başlı Kuyruk: Dizi Kullanan Hızlı İki Başlı Kuyruk Daha önceki bölümde gördüğümüz Dizi Kuyruk, dizinin bir ucuna ekleyen ve diğer ucundan silen Kuyruk veri yapısıdır. Dizi İki Başlı Kuyruk, her iki uca da verimli şekilde ekler veya siler. Liste arayüzünün bir uygulaması olan Dizi Kuyruk’ta kullanılan dairesel dizi tekniğinin aynısını kullanır. Dizi İki Başlı Kuyruk işlemlerinden al(i) ve belirle(i, x) işlemlerini gerçekleştirmeyi kolayca anlayabilirsiniz. Dizinin a[(j + i) mod a.length] konumunda bulunan elemanını getirir veya o değeri be- lirler. ekle(i, x) uygulaması biraz daha ilginçtir. Her zamanki gibi, a’nın dolu olup olmadığını kontrol ediyoruz, ve gerekirse, a’yı yeniden boyutlandırmak için yeniden_boyutlandır() işlem çağrısı yapıyo- | 81 ruz. Önemli olan gereksinim, i değeri küçük (0’a yakın) olduğunda veya büyük (n’e yakın) olduğunda, bu işlemin hızlı olması şartıdır. Bunu gerçekleştirmek için önce, i < n/2 koşulunu kontrol ediyoruz. Eğer öyleyse, a[0],…,a[i - 1] elemanlarını 1 konum sola doğru kaydırıyoruz. Değilse, (i n/2) iken, a[i],…,a[n - 1] elemanlarını 1 konum sağa doğru kaydırıyoruz. Dizi İki Başlı Kuyruk işlemlerinden ekle(i, x) ve sil (i) çalıştırmalarına birer örnek için bkz. Şekil 2.3. 82| ekle(i, x) min(i, n işlemi sırasında gerçekleşen kaydırma hareketi sayısı, - i) elemandan fazla olamaz. Bundan emin olduğumuz için, ekle(i,x) işleminin çalışma zamanı (yeniden_boyutlandır() işleminin maliyeti önemsenmediği takdirde), olarak hesaplanır. sil(i) işleminin uygulaması benzer şekildedir. i < n/2 koşuluna bağlı olarak, a[0],…,a[i 1] elemanlarını 1 konum sağa doğru kaydır- mamız gerekir. Koşul sağlanmazsa, a[i + 1],…,a[n 1] elemanla- rını sola doğru 1 konum kaydırırız. sil(i) işlemi sırasında gerçekleşen kaydırma hareketi sayısı, bu nedenle elemandan fazla olamaz. hiçbir zaman, | 83 Özet Aşağıdaki teorem Dizi İki Başlı Kuyruk veri yapısının performansını özetlemektedir: Teorem 2.3. Dizi İki Başlı Kuyruk veri yapısı, Liste arayüzünü uygular. yeniden_boyutlandır() için yapılan işlem çağrısı maliyeti önemsenmediği takdirde, Dizi İki Başlı Kuyruk, aşağıdaki işlemleri destekler: al(i) ekle(i, x) ve belirle(i, x), işlem başına O(1) zamanda çalışır, ve sil(i), işlem başına zaman- da çalışır. Başlangıçta, Dizi İki Başlı Kuyruk elemanları boş değer taşırken, ekle(i, x) ve sil(i) işlemleri sıralı olarak m defa çağrılırsa, yeni- den_boyutlandır() zamanda çalışır. işlemi için yapılan tüm çağrılar, O(m) toplam 84| Çifte Dizi İki Başlı Kuyruk: İki Yığıt’tan İki Başlı Kuyruk Oluşturulması Bu bölümde, Dizi İki Başlı Kuyruk ile aynı performans sınırını sağlayan, ve iki adet Dizi Yığıt kullandığı için Çifte Dizi İki Başlı Kuyruk adı verilen bir veri yapısını anlatacağız. Çifte Dizi İki Başlı Kuyruk’un asimptotik performansı, Dizi İki Başlı Kuyruk’tan daha iyi değildir, ancak hala üzerinde düşünmeye ve incelemeye değerdir, çünkü iki basit veri yapısını birleştirerek, nasıl daha gelişmiş bir veri yapısının elde edilebileceğine dair iyi bir örnek sunuyor. Çifte Dizi İki Başlı Kuyruk veri yapısı, iki tane Dizi Yığıt listesi kul- lanıyor. Dizi Yığıt, elemanlarını değiştirirken, listenin uç konumlarında daha hızlı performans gösteriyor. Çifte Dizi İki Başlı Kuyruk, front ve back adlarında karşılıklı birer Dizi Yığıt’ı bünyesinde ba- rındırırken, her iki uçta da işlemleri daha hızlı hale getirir. Çifte Dizi İki Başlı Kuyruk’ta bulunan eleman sayısı, n, açık şekilde belirtilmemiştir. Buna gerek yoktur, çünkü back.boyut() ruk’u n = front.boyut() + ile hesaplanmıştır. Yine de, Çifte Dizi İki Başlı Kuy- analiz ederken, n değişkenini kullanmaya devam edeceğiz. | 85 front Dizi Yığıtı, endeksleri 0,…,front.boyut() 1 olan liste ele- manlarını ters sırada depolarken, back Dizi Yığıtı, endeksleri front.boyut(),…,boyut() - 1 olan liste elemanlarını normal sırada depolar. Bu şekilde, al(i) ve belirle(i, x) işlemleri, front veya back için karşılık gelen uygun al(i) ve belirle(i, x) işlem çağrılarına tercüme edilir ve işlem başına O(1) zamanda çalışır. 86| i < front.boyut() koşulunu sağlayan, i endeksindeki herhangi bir eleman, front.boyut() - i - 1 konumunda, ve front yığıtında depolanır, çünkü front yığıtında bulunan elemanlar ters sırada depolanmaktadır. Çifte Dizi İki Başlı Kuyruk’a eleman ekleme ve çıkarma işlemleri- nin çalıştırılmasına birer örnek için bkz. Şekil 2.4. ekle(i, x) işlemi, uygun olan, ya front veya back yığıtı üzerinde çalışır: | 87 ekle(i, x) işlemi, dengele() işlemini çağırarak front ve back Dizi Yığıt’larını dengeliyor. Dengeleme sonucunda boyut() < 2 olmadı- ğı sürece, front.boyut() ve back.boyut() arasındaki fark kesinlikle 3 kattan daha büyük olamaz. 3*front.boyut() 3*back.boyut() front.boyut() back.boyut() ve koşulu dengele() tarafından de- ğişmez olarak garanti edilir. Şimdi, dengele() için yapılan çağrıların maliyeti önemsenmediği takdirde, ekle(i, i< front.boyut() x) maliyetinin analizine değineceğiz. iken, ekle(i, x) işlemi, front.ekle(front.boyut() - i - 1, x) çağrısına göre yapılmaktadır. front yapısı Dizi Yığıt olduğu için çalışma zamanı maliyeti şöyle hesaplanır: Öte yandan, i (i front.boyut() iken, ekle(i, x) işlemi, back.ekle - front.boyut(), x) çağrısına göre yapılmaktadır. Bunun maliyeti, Dikkat ederseniz, (2.1) durumunun, i < n/4 koşulu altında ve (2.2) durumunun i n/4 i < 3n/4 3n/4 için oluştuğunu fark edebilirsiniz. koşulunda ise, front veya back yığıtlarından hangi- sinde işlem görüldüğünden emin olamayız, fakat her iki durumda ve n olduğundan, ekleme işlemi, O(n) = O(i) da, i n/4 = O(n - i) zamanda çalışır. Özetlersek, i > n/4 88| Bu nedenle, ekle(i, x) işlemine yapılan bir çağrının çalışma zamanı, dengele() için gerekli maliyet önemsenmediği takdirde, olarak hesaplanır. ekle(x, i) işlemi ve analizine benzeyen, sil(i) işleminin uygulaması aşağıda gösterilmiştir: | 89 Dengeleme Bu bölümde, dengele() işlemini anlatacağız. ekle(i, x) ve sil(x) tarafından çağrısı yapılan bu işlem, front ve back yığıtlarının ne çok dolu ne de çok boş olmamasını sağlar. İki elemandan daha az boyutta olmadıkları sürece, front ve back yığıtlarının her biri en az n/4 eleman içermelidir. Bu koşul sağlanmadıysa, elemanların ko- numlarını kendi aralarında yer değiştirerek hareket ettirmeliyiz. Böylece, front ve back tam olarak, sırasıyla depolayacak şekilde dengeli hale gelmelidir. ve eleman 90| Burada analiz edilmesi gereken küçük bir konu var. dengele() işlemi dengelemeyi yapıyorsa, o zaman O(n) eleman bir konumdan bir başka konuma taşınmış demektir, ve çalışma zamanı O(n) olarak belirlenir. ekle(i, x) ve sil(x) için yapılan her çağrının, dengele() işlemini çağırdığını göz önünde tutarsanız, bunun iyi bir sonuç olmadığını fark edersiniz. Ortalama olarak, aşağıdaki öneri gösteriyor ki, dengele(), işlem başına sabit miktarda zaman çalışır. Öneri 2.2. Başlangıçta, Çifte Dizi İki Başlı Kuyruk elemanları boş değer taşırken, ekle(i, x) ve sil (i) işlemleri sıralı olarak m 1 defa çağrılırsa, o zaman dengele() için yapılan tüm çağrılar O(m) toplam zamanda çalışır. Kanıt. Eğer dengele(), elemanları kaydırmak zorunda kalırsa, son kaydırmadan bu yana çağrılmış bulunan ekle(i, x) ve sil(i) işlemlerinin sayısı en az n/2 – 1 olarak hesaplanır. Öneri 2.1’in kanıtında olduğu gibi, dengele() toplama çalışma zamanının O(m) olduğunu kanıtlamak için bu yeterlidir. Burada potansiyel işlemi olarak adlandırılan bir teknik kullanarak analiz gerçekleştireceğiz. Çifte Dizi İki Başlı Kuyruk’un potansiyeli, , front ve back boyutları arasındaki fark olarak tanımlanır. Bu potansiyel hakkında ilginç olan gözlem şudur ki, ekle(i, x) veya sil(i) çağrıları dengelemeye gerek duymuyorsa, potansiyel üzerinde en çok 1 artırım etkisine sahiptir. | 91 Şöyle ki, dengele() çağrısı elemanları kaydırdıktan hemen sonra, potansiyel , en çok 1’dir, çünkü, Elemanları kaydıran bir dengele () çağrısından hemen önceki durumu düşünün ve detayları atlayarak varsayın ki, 3*front. boyut()<back.boyut() koşulu sağlandığı için, dengele() işlemiyle elemanlar kaydırılacaktır. Farkında olmalısınız ki, Ayrıca, bu andaki potansiyel, olarak hesaplanır. Bu nedenle, dengele() tarafından yapılan son kaydırmadan itibaren ekle(i, x) ve sil(i) işlemlerine yapılan çağrıların sayısı en az olarak hesaplanır. 92| Özet Aşağıdaki teorem Çifte Dizi İki Başlı Kuyruk’un özelliklerini özetlemektedir: Teorem 2.4. Çifte Dizi İki Başlı Kuyruk, Liste arayüzünü uygular. yeniden_boyutlandır() ve dengele() için yapılan işlem çağrısı maliyeti önemsenmediği takdirde, Çifte Dizi İki Başlı Kuyruk aşağıdaki işlemleri destekler: al(i) ekle(i, x) ve belirle(i, x) işlem başına O(1) zamanda çalışır, ve sil(i) işlem başına za- manda çalışır. Başlangıçta, Çifte Dizi İki Başlı Kuyruk elemanları boş değer taşırken, ekle(i, x) ve sil(i) işlemleri sıralı olarak m defa çağrılırsa, yeniden_boyutlandır() ve dengele() işlemleri için yapılan tüm çağrılar, O(m) toplam zamanda çalışır. | 93 Kök Dizi Yığıt: Alan Kriteri Verimli Olan Dizi Yığıt Uygulaması Önceki bölümlerde anlatmış olduğumuz veri vapılarındaki ortak sorun, kendi verilerini bir veya iki dizide depoladıkları halde, sık sık dengeleme veya yeniden boyutlandırma gerçekleştiği için hiçbir zaman çok dolu hale gelmemeleridir. Örneğin, Dizi Yığıt üzerinde gerçekleştirilen yeniden_boyutlandır () işleminden hemen sonra, takviye a dizisinin sadece yarısı doludur. Daha da kötüsü, a’nın sadece 1/3 oranında veri içerdiği zamanlar vardır. Bu bölümde, boşa harcanan alan sorununu ele alan Kök Dizi Yığıt veri yapısını tartışacağız. Kök Dizi Yığıt, n elemanı diziyi kullanarak depolar. Bu dizilerde, herhangi bir anda, en çok adet kullanılmayan dizi konumu bulunur. Kalan tüm dizi konumları veri depolamak için kullanılır. Bu nedenle, bu veri yapıları n elemanı depolarken en çok alanı boşa harcamıştır. 94| Kök Dizi Yığıt veri yapısı, 0, 1,…,r - 1 olarak numaralandırılan ve blok adı verilen r adet dizi listesinde elemanları depolar, bkz. Şekil 2.5. b bloğu b + 1 elemanı depolar. Bu nedenle, r adet blok toplam olarak, eleman depolar. Yukarıdaki formül Şekil 2.6'de gösterildiği gibi elde edilmiştir. | 95 Tahmin edebileceğiniz gibi, listenin elemanları blok içinde sırayla düzenlenmiştir. Endeksi 0 olan liste elemanı, blok 0’da depolanır, endeksleri 1 ve 2 olan liste elemanları, blok 1’da depolanır, liste endeksleri 3, 4, 5 olan elemanlar blok 2’de depolanır, vb. Üzerinde durmamız gereken başlıca sorun, endeks i verildiğinde hangi bloğun i içerdiğini ve ikincisi bu blok içinde i’ye karşılık gelen endeksi belirlemektir. Kendi bloğu içinde i endeksini belirlemek kolaydır. i endeksi b bloğunun içinde kalıyorsa, blok 0, 1,…,b – 1 içinde bulunan toplam eleman sayısı b(b+1)/2 olarak belirlidir. Bu nedenle, b bloğu içinde i konumu, olarak hesaplanır. Biraz daha zor olanı, b değerini belirleme sorunudur. Endeksi i’den daha az, veya eşit olan elemanların sayısı i + 96| 1’e eşittir. Diğer taraftan, 0,…,b bloklarındaki toplam eleman sayısı (b+1)(b+2)/2’dir. Bu nedenle, b, koşulunu sağlayan en küçük tamsayıdır. Bu denklemi, olarak tekrar yazabiliriz. Buna karşılık gelen b2 + 3b – 2i = 0 ikinci dereceden denkleminin iki çözümü vardır: ve . İkinci çözüm, bizim uygulamamız için hiç mantıklı gelmiyor, çünkü her zaman negatif değer verir. Bu nedenle, çözümünü elde ederiz. Genel olarak, bu çözüm bir tamsayı değildir, ama eşitsizliğimize geri dönersek, koşulunu sağlayan en küçük tamsayı olan b’yi istiyoruz. Sade bir şekilde bu, olarak hesaplanır. | 97 Bu arada, al(i) ve belirle(i, x) metotları açık hale geldi. İlk olarak, uygun b bloğunu ve blok içindeki uygun j endeksini hesaplarız ve daha sonra uygun işlemi gerçekleştiririz: Blok listesini temsilen bu bölümdeki veri yapılarından herhangi birini kullanırsanız, o zaman al(i) ve belirle(i, x) işlemlerinin her ikisi de sabit sürede çalışır. ekle(i, x) işlemi, artık, tanıdık gelir. Öncelikle, blok sayısının r(r+1)/2 = n eşitliğini sağlayıp sağlamadığını kontrol ettikten son- ra, veri yapısının tam dolu olup olmadığını belirleriz. Burada r blok sayısıdır. Eşitlik sağlanmışsa, bir başka blok eklemek için büyült() çağrısı yaparız. Bu işlem sırasında endeksi i olan yeni elemana yer açmak için i,…,n - 1 endeksli elemanlar sağa doğru 1 konum kaydırılır. 98| büyült() işlemi, beklendiği gibi, yeni bir blok ekler: Büyültme işleminin maliyeti önemsenmediği takdirde, işlem başına ekle(i, x) maliyetinin en önemli parçası kaydırma hareketi için ge- rekli maliyettir, ve Dizi Yığıt’daki gibi sadece O(1+n - i) zamanda çalışır. sil(i) işleminin uygulaması, ekle(i, x) işlemine benzer şekildedir. i+1,…,n endeksli elemanları sola doğru 1 konum kaydırır, ve daha sonra, kullanılmayan blokların birini ortadan kaldırmak için küçült() işlemine çağrı yapar. | 99 küçült() işleminin maliyeti önemsenmediği takdirde, sil(i) maliye- tinin en önemli parçası, kaydırma hareketlerine aittir, ve bu nedenle O(n – i) zamanda çalışır. 100| Büyültme ve Küçültmenin Analizi Yukarıdaki ekle(i, x) ve sil(i) analizi, büyült() ve küçült() maliye- tini dikkate almadı. Dizi Yığıt’ın yeniden_boyutlandır() işleminden farklı olarak, büyült() ve küçült() işlemleri herhangi bir veri kopyalamaz. Sadece, r boyutlu bir diziyi bellekten tahsis eder veya serbest bırakır. Bu işlem bazı ortamlarda, sabit zaman, diğerlerinde, r orantılı zaman gerektirebilir. büyült() veya küçült() çağrısından hemen sonra durum berrak hale gelir. Son blok tamamen boştur ve diğer tüm bloklar tamamen doludur. En az r - 1 elemanı ekleyene veya silene kadar, büyült() veya küçült() için hiçbir çağrı yapılmayacaktır. büyült() ve küçült() işlemleri, O(r) zamanda çalışsa bile, bu maliyet en az r - 1 adet ekle(i, x) veya sil(i) işlemi üstünden amortize edilir. Bu nedenle, ekle(i, x) veya sil(i) işlemlerinin amortize maliyeti, işlem başına O(1) zamanda çalışır. | 101 Alan Kullanımı Ardından, Kök Dizi Yığıt veri yapısının kullandığı ek alan miktarını çözümlüyoruz. Özellikle, Kök Dizi Yığıt veri yapısı içinde kullanılabilir olan, fakat halen bir liste elemanını barındırmayan boş alanı saymak istiyoruz. Bu tür elemanların kapladığı alana israf alanı diyoruz. Kök Dizi Yığıt işlemlerinden sil(i), tamamen dolu olmayan iki blok- tan daha fazlasını tutmaya izin vermez. n elemanı depolayan Kök Dizi Yığıt’ın kullandığı blok sayısı, r, bu nedenle, koşulunu sağlar. Bunu ikinci dereceden denklem olarak çözersek, elde edilir. Son iki bloğun boyutları r ve r - 1’dir. Bu yüzden, bu iki blok tarafından israf edilen alan en fazla olarak hesaplanır. Blokları, örneğin, bir Dizi Liste halinde depoluyorsanız, r bloğu depolayan Liste’nin israf alan miktarı, olacak- tır. n ve diğer uygulama bilgilerini depolamak için gerekli alan miktarı O(1)’dir. Bu nedenle, Kök Dizi Yığıt’da israf edilen toplam alan miktarı, olarak hesaplanır. 102| Başlangıçta boş olan ve her seferinde bir eleman ekleyebilen herhangi bir veri yapısı için, bu alan kullanımının en uygun olduğunu ispat edeceğiz. Daha açık olarak, n eleman eklerken, veri yapısının israf ettiği alan miktarı, anlık olsa bile, en azından olur. Boş bir veri yapısı ile başladığımızı ve her seferinde bir tane olmak üzere toplam n elemanı eklediğimizi varsayalım. Bu işlem sonunda, n elemanın tamamı veri yapısında depolanmış ve r bellek blokları- nın arasında dağıtılmış olacaktır. sağlanıyorsa, veri yapısı r bloğun izini kaybetmemek için, r işaretçi (veya referans) kullanmalıdır, ve bu işaretçiler israf alanıdır. sağlanmışsa, yazı ma- sası çekmecesi ilkesi (pigeon hole principle) ile, bir blok en azından boyutunda olacaktır. Böyle bir bloğu öncelikle tahsis ettiğimizi düşünün. Bu tahsisten hemen sonra, blok boştur ve bu nedenle n alan miktarını israf eder. Böylece bir an için olsa bile, elemanın yerleştirilmesi sırasında, veri yapısı israf etmiştir. alan miktarını | 103 Özet Aşağıdaki teorem Kök Dizi Yığıt veri yapısı ile ilgili tartışmamızı özetlemektedir: Teorem 2.5. Kök Dizi Yığıt, Liste arayüzünü uygular. büyült() ve küçült() için yapılan işlem çağrısı maliyeti önemsenmediği takdir- de, Kök Dizi Yığıt aşağıdaki işlemleri destekler: al(i) ekle(i, x) ve belirle(i, x) işlem başına O(1) zamanda çalışır, ve sil(i) işlem başına O(1 + n - i) zamanda çalı- şır. Başlangıçta, Kök Dizi Yığıt elemanları boş değer taşırken, ekle(i, x) ve sil(i) işlemleri sıralı olarak m defa çağrılırsa, büyült() ve küçült() işlemleri için yapılan tüm çağrılar, O(m) toplam zamanda çalışır. n eleman depolayan Kök Dizi Yığıt’ın kullandığı alan (bellek söz- cüğü cinsinden), olarak belirlidir. 104| Karekökleri Hesaplamak Hesaplama Modeli Bölümü’nü okuyan bir okuyucu, Kök Dizi Yığıt veri yapısının, RAM-sözcük hesaplama modeline her zaman uymadığını fark edecektir. Bunun nedeni, karekök işlemi genellikle temel bir işlem olarak kabul edilmediği için, çoğu zaman RAMsözcük modelinin bir parçası değildir. Bu bölümde, karekök işleminin etkin bir şekilde uygulanabilir olduğunu göstereceğiz. Özellikle, da, zamanlı ön işleme sonrasın- uzunluğunda iki dizi oluşturarak, herhangi bir tamsayı için, sabit zamanda değerini hesaplayabileceği- mizi göstereceğiz. Aşağıdaki önerme, x karekökünü hesaplama problemini, bağlı bir x’ karekökünü hesaplamaya indirgemiştir. Öneri 2.3. iken, x ≥1 ve x’ = x - a olsun. Bu durumda, olarak hesaplanır. Kanıt. Şu bağıntının doğru olduğunu göstermek yeterlidir: Her iki tarafın karesini aldığımızda, | 105 elde ederiz. Terimler bir araya getirildiğinde, herhangi bir x ≥ 1 için, sade bir şekilde Başlangıçta problemi biraz daraltalım, 2r ≤ x ≤ 2r+1 için varsayalım; yani, x, ikili tabanda r + 1 bitlik bir tamsayıdır. değerini aldığında, Öneri 2.3’ün ko- şullarını yerine getiren bir x’, ve dolayısıyla elde ederiz. Ayrıca, x’ değerini oluşturan en sağdaki r/2 bitin hepsi 0 değerine sahip olduğu için, mümkün olan her x’ değeri şu bağıntıyı geçerli kılar: Bunun anlamı, olası her x’ değeri için sqrttab değerini depolayan adında bir dizi kullanmalıyız. Biraz daha kesin olmak gere- kirse, Buradan, her nin, için, sqrttab[i] değeri- ’in 2 katı ile sınırlı olduğunu görebilirsiniz. Diğer bir deyiş- le, dizinin değeri konumunda bulunan eleman , veya olmuştur. s yardımıyla 106| değerini de belirleyebilirsiniz. Bunu gerçekleştirmek için, (s+1)2 x koşulunu sağlayana kadar, s, değerini 1 artırın. Bu uygulama sadece ve belirli değeri için çalışmaktadır. Tümü için çalıştırmak istediğinizde, her değeri için birer tane olacak şekilde sqrttab adet farklı dizisini hesaplamalısınız. Dizinin boyutu olup , en çok ile sınırlı olur. Şimdi ortaya çıkıyor ki, birden fazla sqrttab dizisi gereksizdir; sadece = r’ değeri için bir sqrttab dizisine gerek duyarız. log x r denklemini sağlayan herhangi bir x değeri, 2r-r’ ile çarpıla- rak ve, denklemini kullanarak düzeltilebilir. 2 r-r’ x ifadesi aralığında bir değerdir, ve karekökü- nü sqrttab içinde arayabiliriz. Aşağıdaki kod, aralı16 ğındaki negatif olmayan tüm x tamsayıları için, ve 2 boyutundaki sqrttab dizisini kullanarak, değerini hesaplıyor. | 107 Şimdiye kadar ’in nasıl hesaplanacağına kesin gözle baktık. Bu problemi 2r/2 boyutundaki bir logtab dizisiyle şöyle çözebiliriz. ikili x gösteriminin en soldaki bit endeksi olduğu için, logtab dizininde bir endeks olarak kullanılmadan önce, x 2 r/2 için, x bitlerini sağa doğru r/2 konum kaydırılabiliriz. Aşağıda verilen kolay anlaşılır kod, 216 büyüklüğündeki logtab dizisini kullanarak aralığındaki tüm x verileri için değerini hesaplıyor. Son olarak, bütünlük için, logtab ve sqrttab dizilerini başlatan kodu da ekliyoruz: 108| Özetlemek gerekirse sözcük-RAM modelinde, i2b(i) metotuna ait hesaplamalar, sqrttab ve logtab dizilerini depolamak için gerekli olan ekstra belleği kullanarak sabit zamanda çalışır. n iki kat arttığı veya azaldığı zaman, bu diziler yeniden yapılandırılır, ve bunun maliyeti, Dizi Yığıt uygulamasında analiz edilen yeniden_boyutlandır() maliyetiyle aynı şekilde, n’de değişikliğe sebep olan, ekle(i, x) ve sil(i) işlemlerinin sayısı üstünden amortize edilir. | 109 Tartışma ve Alıştırmalar Bu bölümde açıklanan veri yapılarının çoğu, 30 yıl öncesindeki uygulamalarda rastladığımız benzerlik ve çeşitliliği içerir. Örneğin, Dizi Yığıt, Dizi Kuyruk Kuyruk ve Çifte Dizi İki Başlı Kuyruk yapıları, Yığıt, ve Çift Başlı Kuyruk kullanarak kolayca uygulanabilir. Knuth bu yapıları gerçekleştirdi [46, bkz.Hızlı Dizi Yığıtı: Optimize Dizi Yığıtı Bölümü]. Kök Dizi Yığıtı’nı, ilk olarak, Brodnik ve arkadaşları [13] tanımladı ve Alan Kullanımı Bölümü’nde verilen sınıra benzer bir alt sınırı ispatladı. Aynı zamanda, i2b(i) işlemi sırasında karekök hesabından kaçınmak amacıyla, daha karmaşık blok boyutlarını kullanan farklı bir yapı kullanılabilir. Böyle bir tasarımda, i’nin dahil olduğu blok ile endekslenen bloktur. i+1 sayısının ikili gösteriminde, en önemli konumdaki 1 biti, endeksi gösterir. Bazı bilgisayar mimarilerinde, 1-bitinin konumu, verilen bir tamsayı için otomatik olarak çalıştırılan komutlarla hesaplanmaktadır. Kök Dizi Yığıtı ile ilgili bir başka veri yapısı da, Goodrich and Kloss’un iki seviyeli katmanlı vektörüdür [35]. al(i, x) ve belirle(i, x) işlemlerini sabit sürede, ve ekle(i, x) ve sil(i) işlemlerini zamanda çalıştırır. Kök Dizi Yığıt veri yapısı ile ilgili olarak, Alıştırma 2.11’de önerilen uygulamaya benzer daha iyi performans gösterebilir. 110| Alıştırma 2.1. Dizi Yığıt uygulamasında, sil(i) metoduna yapılan birinci çağrı sonrasında, a, takviye dizisi, n + 1 adet null-olmayan değeri içerir. Dizi Yığıt, sadece n eleman depoladığı için, nullolmayan fazladan değer nereye gitmiştir? Java Çalışma Zamanı Ortamı’nın bellek yöneticisi bundan nasıl etkilenir? Tartışın. Alıştırma 2.2. Liste arayüzüne ait, hepsiniEkle(i, c) işlemi, c koleksiyonunda bulunan her elemanı listenin i’nci konumuna yerleştirir (ekle(i, x) işlemi, c = {x} özel durumudur). Bu bölümde anlatılan veri yapılarını kullanarak, hepsiniEkle(i, c) işlemini, verimli olarak tasarlayın ve uygulayın. ekle(i, x) işlemini yineleyerek çağırmak neden verimli olmaz? Açıklayın. Alıştırma 2.3. Kuyruk arayüzünün bir uygulaması olan, Rasgele Kuyruk veri yapısını tasarlayın ve uygulayın. sil() işlemi, kuyrukta bulunan tüm elemanlar arasından rasgele seçilmiş bir elemanı siler. (Rasgele Kuyruk’u, eleman ekleyen, değerini getiren ve rasgele konumdan eleman silen bir torba (bag) gibi düşünün). Rasgele Kuyruk’un ekle(x) ve sil() işlemleri sabit zamanda çalışır. Alıştırma 2.4. Liste arayüzünün bir uygulaması olan, Üç Uçlu Kuyruk’u tasarlayın ve uygulayın. al(i) ve belirle(i, x) işlemleri sabit zamanda çalışırken, ekle(i, x) ve sil(i) işlemleri, zamanda çalışır. | 111 Başka bir deyişle, listenin her iki ucunda veya orta konumunda bulunan veriler için işlemler en hızlı çalışır. Alıştırma 2.5. a dizisi üzerinde çalışan, yer_değiştir(a, r) işlemi, her i {0,…,a.length} için, a[i] elemanını, a[(i + r) mod a.length] konumuna taşır, ve yerini değiştirir. yer_değiştir(a, r) işlemini uygulayın. Alıştırma 2.6. Liste’nin i konumunda bulunan elemanları [(i + r) mod n] konumuna taşıyan, yer_değiştir(r) işlemini uygu- layın. Dizi İki Başlı Kuyruk veya Çifte Dizi İki Başlı Kuyruk veri yapısına ait, yer_değiştir(r) işlemi, O(1 + min{r, n – r}) zamanda çalışmalıdır. Alıştırma 2.7. Dizi İki Başlı Kuyruk veri yapısına ait, ekle(i, x), sil(i), ve yeniden_boyutlandır() işlemlerini yeniden yazın. Yeni uygulamanızda, kaydırma hareketlerini gerçekleştirirken, daha hızlı çalışabilen System.arraycopy(s, i, d, j, n) fonksiyonunu kullanın. Alıştırma 2.8. Dizi İki Başlı Kuyruk uygulamasında kullanılan % işleci bazı sistemlerde masraflı çalışır. Bunu kullanmak yerine, a.length, 2 üssüne ait bir sayı iken, gerçeğinden yararlanın. (Burada, & işleci, bitdüzeyi-ve işlemini gösterir). 112| Alıştırma 2.9. Modüler aritmetik hesabı yapmayan, Dizi İki Başlı Kuyruk veri yapısını tasarlayın ve uygulayın. Verilerin tamamı, bir dizi içinde, sırayla ardışık bloklar üzerinde yerleştirilmiştir. Dizi, başlangıç veya den_yapılandır() son sınırdan dışarı taştığı anda, yeni- işlemi çalışır. Veri yapısı üzerindeki tüm işlemle- rin amortize maliyeti, Dizi İki Başlı Kuyruk ile aynı zamanda performansı göstermelidir. Alıştırma 2.10. İsraf alanı sil(i, x) işlemleri O(1 + min{i, n - i}) zamanda çalışan Kök Dizi Yığıt versiyonunu tasarlayın ve uygulayın. Alıştırma 2.11. İsraf alanı sil(i, x) Yığıt olan, ancak ekle(i, x) ve işlemleri olan, ancak ekle(i, x) ve zamanda çalışan Kök Dizi versiyonunu tasarlayın ve uygulayın (Fikir için, bkz. AVListe: Alan-Verimli Liste Bölümü). Alıştırma 2.12. İsraf alanı sil(i, x) Yığıt işlemleri olan, ancak ekle(i, x) ve zamanda çalışan Kök Dizi versiyonunu tasarlayın ve uygulayın (Fikir için, bkz. AVListe: Alan-Verimli Liste Bölümü). Alıştırma 2.13. Kübik Dizi Yığıtı veri yapısını tasarlayın ve uygulayın. Üç seviyeli bu yapı, Liste arayüzünü uygular. Kullandığı O(n 2/3 ) israf alanıyla, ekle(i, x) ve sil(i) işlemlerini O(n1/3) amortize maliyetle çalıştırırken, al(i) ve belirle(i, x) işlemleri sabit zamanda çalışır. | 113 Bölüm 3 Bağlantılı Listeler Bu bölümde, Liste arayüzü uygulamalarını çalışmaya devam edeceğiz; bu kez dizi tabanlı veri yapıları yerine, işaretçi-tabanlı veri yapılarını kullanacağız. İnceleyeceğimiz yapılar, liste elemanlarını içeren düğümlerden oluşuyor. Düğümler, referanslar (işaretçiler) yoluyla bir dizi halinde bir araya bağlanmaktadır. İlk olarak, teklibağlantılı listeleri çalışacağız. Bu veri yapısı, Yığıt ve (FIFO) Kuyruk işlemlerini, işlem başına sabit zamanda çalıştırır. Daha sonra, çifte-bağlantılı listelere geçeceğiz. Bu yapı, İki Başlı Kuyruk işlemlerini sabit zamanda çalıştırır. Liste arayüzünün dizi tabanlı uygulamaları, bağlantılı listeler ile kıyaslandığında, bazı avantaj ve dezavantajlar ile karşılaşılır. Birinci dezavantajı, herhangi bir elemana erişmek için, sabit zamanlı al(i) ve belirle(i, x) işlemlerini kullanma yeteneğimizi kaybedebili- riz. Bunun yerine, i'nci elemana ulaşana kadar, liste üzerindeki her bir eleman üzerinden yürümek zorunda kalırız. En önemli avantajı ise, daha dinamik olmasıdır: u herhangi bir liste düğümü olduğu takdirde, u listenin hangi konumunda bulunursa bulunsun, u için bir referans verilirse, u silinebilir veya u’ya bitişik bir düğüm, sabit zaman içinde eklenebilir. 114| TBListe: Tekli-Bağlantılı Liste TBListe (tekli-bağlantılı liste), bir dizi Düğüm’den oluşur. Her u düğümü, u.x verisi, ve dizinin bir sonraki düğümüne referans veren, u.next işaretçisini depolar. Dizinin son düğümü, w için, w.next = null olarak hesaplanır. Verimliliği artırmaya yarayan head ve tail değişkenleri, listenin birinci düğümü ile son düğümünü izlemek için kullanılır. Bunun yanı sıra, dizinin uzunluğunu takip etmek için, n tamsayısı kullanılır: | 115 TBListe üzerinde uygulanan Yığıt ve Kuyruk işlemlerinden bazıları Şekil 3.1'de gösterilmiştir. Dizinin başındaki elemanları ekleyerek ve silerek, Yığıt işlemlerinden yığ() ve yığıttan_kaldır() işlemleri, TBListe tarafından verimli şekilde gerçekleştirilir. yığ() işlemi, veri değeri x olan yeni bir u düğümü oluşturur; bunu u.next değişkenini kullanarak eski listeye ekler, ve listenin yeni başı, u olarak hesaplanır. En sonunda, n, 1 artırılır, çünkü TBListe’in boyutu 1 artmıştır: yığıttan_kaldır() işlemi, TBListe düğümlerinin boş olup olmadığını kontrol ettikten sonra, listenin başını head=head.next olarak belirler, ve n, 1 azaltılır. Son eleman silinirken özel bir durum oluşur ki, burada, listenin sonu tail=null olarak belirlenmiştir. 116| Açıktır ki, yığ(x) ve yığıttan_kaldır() işlemlerinin her ikisi de O(1) zamanda çalışır. | 117 Kuyruk İşlemleri Bir TBListe, FIFO Kuyruk işlemlerinden ekle(x) ve sil() işlemlerini sabit zamanda gerçekleştirir. Silmeler, listenin başından yapılır, ve yığıttan_kaldır() işlemi ile eşdeğerdir: Diğer yandan eklemeler, listenin sonundan yapılır. Çoğu durumda bu, tail.next = u belirlenmesi ile gerçekleştirilir, burada u, x verisini içeren, yeni oluşturulan düğümdür. Ancak n=0 olduğunda, özel bir durum ortaya çıkar. Bu özel durumda, tail = head = null olarak belirlenmiştir. Ekleme sonucunda, hem tail ve hem head, u olarak belirlenir. 118| Açıktır ki, ekle(x) ve sil() işlemlerinin her ikisi de O(1) zamanda çalışır. Özet Aşağıdaki teorem TBListe performansını özetlemektedir: Teorem 3.1. TBListe, Yığıt ve (FIFO) Kuyruk arayüzlerini uygular. yığ(x), yığıttan_kaldır(), ekle(x) ve sil() işlemleri, işlem başına O(1) zamanda çalışır. TBListe, neredeyse, İki Başlı Kuyruk işlemlerinin tamamını uygu- lar. Tek eksik işlem, TBListe düğümlerinin sonuncusunu ortadan kaldırmaktır. Son TBListe düğümünün silinmesi zordur, çünkü öyle bir şekilde güncellenmesi gerekir ki bu, TBListe içindeki sondan bir önceki w düğümüne işaret etsin; bu, w.next = tail olan w düğümüdür. Ne yazık ki, w’ya ulaşan tek yol, TBListe’nin en başındaki düğümden başlanıp, adım adım ilerleyerek n – 2 adım atılmasıdır. | 119 ÇBListe: Çifte-Bağlantılı Liste ÇBListe (çifte-bağlantılı liste) veri yapısı, TBListe’ye çok benzerdir, ancak ÇBListe’deki her u düğümünün ardından u.next, ve öncesinden u.prev bağlantılarına referans verilmiştir. TBListe uygulamasında, dikkate alınması gereken sadece birkaç özel durum olduğunu öğrendik. Örneğin, son elemanı silmek, veya boş bir TBListe’ye eleman eklemek için, listenin baş ve son elemanları doğru olarak güncellenmelidir. ÇBListe’ye baktığımızda, özel durum sayısının önemli ölçüde arttığını görürüz. Belki de, ÇBListe için, tüm bu özel durumların üstesinden gelmenin en temiz yolu, herhangi bir veri içermeyen, sadece yer tutucu görevini gören bir dummy düğümünü tanıtmaktır. Bu sayede, özel düğüm kavramı ortadan kalkar; her düğümün, bir sonraki ve bir önceki bağlantısı mevcut olur. Listedeki son düğümü izleyen düğüm, dummy düğümdür. Listedeki ilk düğümden önce gelen düğüm, yine dummy düğümdür. Böylece, Şekil 3.2’de gösterildiği gibi, listenin düğümleri, bir döngü içinde iki kat olmak üzere çifte bağlanmıştır. 120| ÇBListe elemanlarına belirli bir endeks pozisyonundan erişmek zor değildir; ya listenin başından (dummy.next) başlar, ve ileri yönde çalışırız, veya listenin sonundan (dummy.prev) başlar ve geri yönde çalışırız. i'nci düğüme erişmek işlemi, O(1 + min {i, n – i}) zamanda çalışır: al(i) ve belirle(i, x) işlemleri de artık kolaydır. Gerçekleştirmek için ilk olarak, i'nci düğümü buluruz ve daha sonra x değerini alır, veya belirleriz. | 121 Bu işlemlerin çalışma zamanı, i’nci düğümü bulmak için gerekli zaman ile sınırlıdır, ve bu nedenle O(1 + min {i, n – i}) olarak hesaplanır. 122| Ekleme ve Çıkarma ÇBListe’nin w düğümüne referansınız varsa, ve w düğümünden önce u düğümünü eklemek istiyorsanız, o zaman u.next=w, ve u.prev = w.prev u.next.prev olarak belirledikten sonra gerekli u.prev.next ve düzenlemelerini yapmalısınız (bkz. Şekil 3.3). Dummy düğüm sayesinde, w.prev ve w.next’in mevcut olmaması mümkün değildir. ekle(i, x) liste işlemini gerçekleştirmek, şimdi çok kolay hale gel- miştir. ÇBListe’de yer alan i’nci düğümü buluruz. x verisini taşıyan yeni bir u düğümünü hemen öncesine ekleriz. ekle(i, x) işleminin sabit olmayan tek çalışma zamanı bileşeni, i'nci düğümü bulmak için gereken zamandır (alDüğüm(i) kullanarak). | 123 Bu nedenle, ekle(i, x) işlemi, O(1 + min {i, n – i}) zamanda çalışır. ÇBListe’den w w.next düğümünü silmek kolaydır. Sadece w.prev ve işaretçilerini belirlemelisiniz; öyle ki listenin geri kalanı, w düğümünü atlasın. Yine, dummy düğümün kullanımıyla herhangi bir özel durumu dikkate alma ihtiyacı ortadan kalkar: Şimdi sil(i) işlemi çok kolay hale gelir. i endeksli düğümü bulup listeden çıkarırız: Bu işlemin en masraflı bileşeni, alDüğüm(i) kullanarak i’nci düğümü bulmaktır. Bu nedenle, sil(i) işlemi, O(1+min {i, n – i}) zamanda çalışır. 124| Özet Aşağıdaki teorem ÇBListe performansını özetlemektedir: Teorem 3.2. ÇBListe, Liste arayüzünü uygular. al(i), belirle(i, x), ekle(i, x) ve sil(i) işlemleri, işlem başına O(1+min {i, n – i}) za- manda çalışır. Değinilmesi gereken bir başka konu da, alDüğüm(i) için yapılan işlem çağrısı maliyeti önemsenmediği takdirde, tüm ÇBListe işlemleri sabit zaman alır. Bu durumda, ÇBListe üzerindeki işlemlerin tek masraflı bileşeni, ilgili düğümü bulmaktır. İlgili düğüme eriştikten sonra, düğüm ekleme, silme veya o düğüme ait veri erişimi, sadece sabit zaman alır. Bölüm 2’deki dizi tabanlı Liste uygulamalarında, bunun tersi durum sözkonusudur. Bu uygulamalarda, ilgili dizi elemanına sabit zamanda erişilir. Bununla birlikte, ekleme veya silme işlemleri, dizi elemanlarının yerlerini değiştireceği için, genellikle, sabit olmayan zamanda çalışır. Bağlantılı liste yapıları, liste düğümlerine referansların, dış yollarla elde edilebildiği uygulamalar için çok uygundur. Bunun bir örneği, Java Koleksiyonlar Çerçevesi’nde bulunan LinkedHashSet veri yapısıdır. Bu yapı, veri elemanlarını çifte bağlı listede saklarken, çifte-bağlantılı liste düğümlerini de karma bir tabloda (bkz. Bölüm | 125 5) depolar. LinkedHashSet elemanını silmek istediğinizde, karma tablo, sabit zamanda ilgili liste düğümünü bulmak için kullanılır ve daha sonra listedeki düğüm, sabit zamanda silinir. 126| AVListe: Alan-Verimli Liste Bu bölümde, bağlantılı listenin derinlerinde bulunan elemanlara erişmek için gereken zamanın yanı sıra, kullanım alanı ile ilgili sorunu çözmeye çalışacağız. Bir AVListe’nin her düğümü, kendisinden sonraki ve önceki düğümlere ait, iki ek referans gerektirir. Bir düğümün iki bilgi alanı, listenin bakımı için ve sadece bir alan veri depolamak için ayrılmıştır! Bir AVListe (Alan-Verimli Liste), basit bir fikir kullanarak, harcanan bu alanı azaltır: Liste elemanlarını ÇBListe’de depolamak yerine, çeşitli elemanları içeren bir (dizi) blokta depolarız. Daha doğrusu, AVListe b blok boyutu tarafından parametrelendirilmiştir. AVListe’de yer alan her tek düğüm, b + 1 elemanı saklayacak kadar alana sahip bir blok depolar. Daha sonra açık hale gelecek nedenlerden dolayı, eğer her blokta İki Başlı Kuyruk işlemlerini yapabilirsek yararlı olacaktır. Bunun için seçtiğimiz veri yapısı, Dizi İki Başlı Kuyruk: Dizi Kullanan Hızlı İki Başlı Kuyruk Bölümü'nde anlatılan, Dizi İki Başlı Kuyruk yapısından türetilmiş olan Sınırlı İki Başlı Kuyruk’tur. Sınırlı İki Başlı Kuyruk, küçük bir farkla Dizi İki Başlı Kuyruk’tan ayrılır: Yeni bir Sınırlı İki Başlı Kuyruk oluşturulduğunda, takviye dizisi olan, a dizisinin büyüklüğü, b + 1 ile sabitlenmiştir; boyutu hiçbir zaman artmaz veya azalmaz. Sınırlı İki Başlı Kuyruk’un önemli bir özelliği de, elemanları başa veya sona, sabit zamanda eklemeye | 127 veya silmeye olanak tanır. Elemanların, bir bloktan, bir başka bloğa kaydırılması sırasında, bu özellikten yararlanacağız. Bunun anlamı, AVListe, çifte-bağlantılı liste bloklarından oluşur: 128| Alan Gereksinimleri Bir bloğun eleman sayısı, AVListe’de çok sıkı kısıtlanmıştır: Bir blok, son blok olmadığı sürece, o blok, en az b – 1 ve en çok b+1 eleman içerir. Bunun anlamı, AVListe, n eleman içeriyorsa, o zaman blok sayısı en fazla, olarak hesaplanır. Sınırlı İki Başlı Kuyruk, her blok için, b + 1 uzunluğunda bir dizi içerir, ancak, sonuncu blok dışındaki her blok için, en fazla sabit miktarda bir alan, bu dizide israf edilir. Bir blok tarafından kullanılan bellek de, sabittir. Bunun anlamı, AVListe’nin israf alanı, sadece O(b + n/b) olur. Sabit bir faktörü içinde bir b değeri seçerek, AVListe’nin alan gereksinimini, Kök Dizi Yığıt: Alan Kriteri Verimli Olan Bir Dizi Yığıt Uygulaması, Alan Kullanımı Bölümü'nde verilen alt sınırına yaklaştırabiliriz. Elemanların Bulunması AVListe ile yüzleştiğimizde, ilk motivasyonumuz, belirli bir i en- deksine ait, liste elemanını bulmaktır. Bir elemanın, listedeki yerini oluşturan iki bölüm şunlardır: 1. i endeksli elemanı içeren bloğu içeren u düğümü; ve 2. kendi bloğu içinde elemanın j endeksi. | 129 Belirli bir elemanı içeren bir bloğu bulmak için, ÇBListe’de olduğu gibi, aynı şekilde devam etmeliyiz. Listenin başından başlayıp, ileri yönde hareket etmeliyiz veya listenin sonundan başlayıp, istenen düğüme ulaşana kadar, geriye doğru hareket etmeliyiz. Bir düğümden ötekine geçerken, bütün bloğu, bir seferde atlamalıyız. Unutmayın ki, en fazla bir blok dışında, her blok en az b – 1 eleman içerir, bu nedenle, aramamız sırasında atılan her adım, bizi 130| aradığımız elemana, b – 1 eleman kadar yaklaştırır. İleriye doğru arama yapıyorsanız, O(1 + i / b) adım sonrasında, istediğiniz düğüme ulaşılırsınız. Geriye doğru arama yapıyorsanız, O(1 + (n – i) / b) adım sonrasında, istediğiniz düğüme ulaşırsınız. Algoritma, i değerine bağlı olarak, bu iki miktarın daha küçüğünü ele alır, böylece, i endeksli elemanı bulmak O(1 + min {i, n – i} / b) zamanda çalışır. i endeksli elemanı nasıl bulacağınızı biliyorsanız, al(i) ve belirle(i, x) işlemleri için doğru blokta belirli bir endeksi almayı, veya belir- lemeyi kodlamanız gerekir: Bu işlemlerin çalışma zamanları, elemanı bulmak için gereken zaman ile kısıtlanmıştır, bu nedenle, O(1 + min {i, n – i} / b) zamanda çalışır. | 131 Elemanların Eklenmesi AVListe’ye eleman eklenmesi biraz daha karmaşıktır. Genel duru- mu dikkate almadan önce, daha kolay olan, x elemanını listenin sonuna ekleyen, ekle(x) işlemini gözden geçirelim. Son blok doluysa, (veya hiçbir blok henüz mevcut değilse), o zaman önce yeni bir blok tahsis ederiz, ve blok listesine ekleriz. Şimdi, son bloğun var olduğundan, ve onun boş olmadığından emin halde, x elemanını bu bloğa ekleriz. ekle(i, x) kullanarak, listenin içinde bir yere eleman eklediğimizde, işler biraz daha karışık hale gelir. i'nci liste elemanını içeren u düğümünün bloğuna erişmek için, ilk olarak, i bulunur. u bloğunun içine, x elemanını eklemek sorununu çözmek için, u bloğunun, zaten b + 1 eleman içerdiği dolu olan durumu için hazırlıklı olmak zorundayız. Bunun anlamı, x için o blokta yer yoktur. u0, u1, u2,... düğümlerinin işaretçilerini u, u.next, u.next.next olarak belirleyelim. u0, u1, u2,… düğümleri, x elemanını eklemek 132| için bir alan sağlanmasını araştırırken üç durumla karşılaşabilirsiniz (bkz. Şekil 3.4): 1. Dolu olmayan bir ur düğümünü hızlıca (r + 1 ≤ b adımda) buluruz. ur düğümüne ait bloktan diğerine r eleman yer değiştirir, böylece x elemanını eklemek için ur düğümünde serbest alan oluştururuz. 2. Hızlıca (r + 1 ≤ b adımda) bulduğumuz blok listelerinin sonu- na geliriz. Bloğun sonuna yeni bir boş blok ekleriz ve birinci halde olduğu gibi devam ederiz. 3. Dolu olmayan bir ur düğümünü bulamıyoruz. Bu durumda, u0,…,ub-1 dizi bloklarının toplam sayısı, b iken, bu blokların her biri, b + 1 eleman içerir. En son bloğun ardına, yeni bir blok ub bloğu ekleriz, ve orijinal b(b + 1) elemanları yayarız. Böylece her | 133 bir u0,…,ub bloğu tam olarak b eleman içerir. u0 bloğu, şimdi, tam olarak b eleman içermektedir, ve bu nedenle eleman eklenebilir. ekle(i, x) işleminin çalışma zamanı, yukarıda ortaya konan üç du- rumdan hangisine bağlı olduğuna göre değişir. 1. ve 2. durumlar, elemanları incelemek ve değiştirmek için, en çok b blok kullanır, bu nedenle O(b) zamanda çalışır. 3. durumda yayıl(u) işlemi çağrıldığında, b(b + 1) eleman yer değiştirir ve O(b2) zamanda çalışır. 3.durumun maliyeti önemsenmediği takdirde (daha sonra amortizasyon hesabıyla ele alınacaktır), i endeksinin yerini belirlemek, ve x elemanını eklemek, O(b + min {i, n – i} / b) zamanda çalışır. 134| Elemanların Silinmesi Bir AVListe’den eleman silinmesi, eklemeye benzerdir. i endeksini içeren u düğümünün yerini bulduktan sonra, u düğümüne ait blok, b – 1 elemandan daha azına sahip olduğu için, bir elemanı u dü- ğümünden silmenin olanaksız olduğu durum için hazırlıklı olmalıyız. Yine, u0, u1, u2,... düğümlerinin işaretçilerini u, u.next, u.next.next b – 1 olarak belirleyelim. u0 bloğunun boyutunun en azından olması için u0, u1, u2,… düğümlerinden herhangi birinden bir eleman ödünç almalıyız. Bunu araştırırken, üç durum oluşabilir (bkz. Şekil 3.5): 1. Hızlıca (r + 1 ≤ b adımda) bloğu b – 1 elemandan daha fazla eleman içeren bir düğüm buluruz. Bu durumda, bir bloktan öncekine r eleman yer değiştirir. Böylece ur düğümünün ekstra blok elemanı, u0 düğümünün ekstra blok elemanı haline gelir. Bunu takiben u0 2. bloğundan istenen elemanı sileriz. Hızlıca (r + 1 ≤ b adımda) bulduğumuz, blok listelerinin so- nuna geliriz. Bu durumda, ur düğümüne ait blok son bloktur ve ur düğümüne ait bloğunun en az n – 1 eleman içermesine gerek yoktur. Bu nedenle, yukarıdaki gibi devam etmeliyiz ve u0 düğümünün ekstra elemanı yapmak için ur düğümünden bir elemanı ödünç al- | 135 malıyız. Bu ödünç alma sonrasında, ur düğümünün bloğu boş hale gelirse, listeden sileriz. 3. b adım sonrasında, en fazla b – 1 eleman içeren herhangi bir blok bulamadığımız takdirde, u0,...,ub-1 dizi bloklarının her biri b – 1 eleman içerir. Tüm bu b(b – 1) elemanı b – 1 adet bloğun her birinde tam olarak b eleman olacak şekilde, u0,..., ub-2 düğümleri halinde yeniden yapılandırırız, ve şimdi boş olan, ub-1 düğümünü sileriz. u0 bloğu şimdi b eleman içermektedir ve bu nedenle eleman silinebilir. 136| ekle(i, x) işlemine benzer şekilde, sil(i) işlemi, 3.durumdaki birarayagetir(u) işleminin maliyeti önemsenmediği takdirde, O(b + min {i, n – i} / b) zamanda çalışır. | 137 yayıl(u) ve birarayaGetir(u) Yöntemlerinin Amortize Edilmiş Analizi Şimdi, ekle(i, x) ve sil(i) işlemleri tarafından çağrılabilen yayıl(u) ve birarayaGetir(u) işlemlerinin maliyetini düşünüyoruz. Bütünlüğü sağlamak adına kodları aşağıda verilmiştir: Bu işlemlerin her birinin çalışma zamanı, iki iç içe döngü tarafından kısıtlanmıştır. Hem iç ve hem dış döngüler, en fazla b + 1 defa çalışır, bu nedenle, bu işlemlerin her biri O((b+1)2) = O(b2) top- 138| lam zamanda çalışır. Ancak, aşağıdaki önerme, bu işlemlerin ekle(i, x) ve sil(i) işlemlerine yapılan her b’nci çağrıda bir defa çalış- tırıldığını gösteriyor. Önerme 3.1. Boş bir AVListe oluşturulursa ve ekle(i, x) ve sil(i) işlemleri sıralı olarak m ≥ 1 defa çağrılırsa, o zaman yayıl() ve birarayaGetir() işlemleri için yapılan tüm çağrılar, O(bm) toplam zamanda çalışır. Kanıt. Burada, yine bize güç vaat eden amortize analiz işlemini kullanacağız. Bir u düğümüne ait blok, b eleman içermiyorsa, düğümün kırılgan olduğu söylenir (öyle ki u, ya son düğümdür veya bloğunda b – 1, veya b + 1 eleman vardır). Bloğunda, b eleman içeren herhangi bir düğümün engebeli olduğu söylenir. Burada, biz sadece ekle(i, x) işlemini ve yayıl(u) işlemine yaptığı çağrı sayısı ile olan ilişkisini dikkate alacağız. sil(i) ve birarayaGetir(u) işlemlerinin analizi benzerdir. Bir AVListe’nin potansiyeli, içerdiği kırılgan düğümlerin sayısı olarak tanımlanır. ekle(i, x) çalıştığında, 1. durum oluştuğunda, sadece bir ur düğümünün boyutu değişmiştir. Bu nedenle, en fazla bir ur düğümü engebeli olmaktan çıkar, kırılgan olmaya geçer. 2. durum oluştuğunda, yeni bir düğüm oluşturulur ve bu düğüm kırılgandır, ancak başka hiçbir düğüm boyut değiştirmez. Bu nedenle, kırılgan düğümlerin sayısı, 1 artar. Böylece, 1. veya 2. durumlarda, AVListe’nin potansiyeli en fazla 1 artar. | 139 Son olarak, 3.durum oluştuğunda, bunun nedeni, u0,...,ub-1 düğümlerinin hepsinin kırılgan olmasıdır. Bunu takiben, yayıl() çağrılır, ve bu b kırılgan düğüm, b + 1 engebeli düğüm ile yer değişir. Son olarak, x elemanı, u0 bloğuna eklenir ve u0 kırılgan hale gelir. Toplam olarak, potansiyel b – 1 kadar düşer. Özet olarak, potansiyelin başlangıç değeri, 0 olarak hesaplanır (listede hiçbir düğüm yoktur). 1. durum veya 2. durum her oluştuğunda, potansiyel en çok 1 artar. 3. durum oluştuğunda, potansiyel b – 1 azalır. (Kırılgan düğüm sayısı olan) potansiyel, hiçbir zaman 0'dan az değildir. Şu sonuca varabiliriz ki, 3. durum her oluştuğunda, 1. Durum veya 2. durum en az b – 1 defa oluşmuştur. Böylece, yayıl(u) işlemine yapılan her çağrı için, ekle(i, x) işlemine en azın- dan, b çağrı yapılmıştır. 140| Özet Aşağıdaki teorem AVListe veri yapısının performansını özetliyor: Teorem 3.3. AVListe, Liste arayüzünü uygular. yayıl(u) ve birarayaGetir(u) çağrılarının maliyeti önemsenmediği takdirde, blok boyutu b olan AVListe aşağıdaki işlemleri destekler: al(i) ve belirle(i, x) işlem başına O(1 + min {i, n – i} / b ) zamanda çalışır, ekle(i, x) ve sil(i) işlem başına O(b + min { i, n – i } / b ) zamanda çalışır. Başlangıçta, AVListe elemanları boş değer taşırken, ekle(i, x) ve sil(i) işlemleri sıralı olarak m defa çağrılırsa, yayıl(u) ve birarayaGetir(u) işlemleri için yapılan tüm çağrılar, O(bm) toplam zamanda çalışır. n eleman depolayan AVListe’nin kullandığı alan, n + O(b + n / b) olarak belirlidir. AVListe’nin uygulaması, Dizi Liste ve ÇBListe arasında seçim yap- mayı gerektiriyor. Blok büyüklüğü, b, göz önünde tutularak bu iki yapıdan biri, göreceli olarak seçilmelidir. En uç noktada, b=2 iken, her AVListe düğümü, en çok üç değer depolayabilir. ÇBListe de, hemen hemen aynıdır. Diğer bir uçta, b n iken, Dizi Liste’de ol- | 141 duğu gibi tüm elemanlar, sadece bir dizide depolanabilir. Bu iki uç arasında iseniz, bir liste elemanını eklemek veya kaldırmak için gereken zaman ile belirli bir liste elemanını bulmak için gereken zaman arasında bir seçim yapmanız gerekiyor. 142| Tartışma ve Alıştırmalar Tekli-bağlantılı ve çoklu-bağlantılı listelerin her ikisi de, 40 yıldan bu yana programlarda kullanılmış olan ve kabul edilmiş tekniklerdir. Bunlar, örneğin, Knuth tarafından tartışılmıştır [46; Hızlı Dizi Yığıtı: Optimize Dizi Yığıtı; Çifte Dizi İki Başlı Kuyruk: İki Yığıt’tan İki Başlı Kuyruk Oluşturulması Bölümleri]. AVListe, veri yapıları için iyi bilinen bir alıştırma gibi görünüyor. Hatta AVListe, döngüsüz bağlantılı liste olarak adlandırılabilir [69]. Bir çifte-bağlantılı listede alan tasarrufu yapmanın bir başka yolu XOR-listelerini kullanmaktır. XOR listesinde, her u düğümü, u.önceki ve u.sonraki işlemlerini bitsel x–veya işlemine tabi tutan, u.sonrakiönceki dummy ve (ilk düğüme, veya liste boşsa dummy’e eşit olan) dummy.sonraki u.önceki adında bir işaretçi ile gösterilir. Listenin kendisi, olmak üzere, iki işaretçi depolar. Bu teknik, u ve işaretçilerini kullanarak, u.sonraki = u.önceki^u.sonrakiönceki formülüyle, u.sonraki değerinin hesaplanabileceğini anlatır. (Burada ^ işleci, iki argümanının bitsel x–veya hesabını yapmakta kullanılmıştır). Bu teknik, kodu biraz zorlaştırır, ve – Java dahil – çöp toplayan bazı dillerde, bu tekniği uygulamak mümkün değildir, ancak, düğüm başına yalnızca bir işaretçi gerektiren, bir çifte- | 143 bağlantılı liste uygulamasını sunmaktadır. XOR-listelerinin ayrıntılı bir tartışması için bkz. Sinha’nın dergi makalesi [70]. Alıştırma 3.1. TBListe arayüzüne ait, yığ(x), yığıttan_kaldır(), ekle(x) ve sil() işlemlerinde ortaya çıkabilecek bütün özel durum- ları önlemek için dummy düğümünün kullanılması neden mümkün değildir? Alıştırma 3.2. TBListe’nin, sondan ikinci elemanını döndüren, sondanİkinci() işlemini tasarlayın ve uygulayın. Bu işlemi uygular- ken, liste eleman sayısı olan, n değişkenini kullanmayın. Alıştırma 3.3. Liste işlemlerinden al(i), belirle(i, x), ekle(i, x) ve sil(i) işlemlerini TBListe arayüzüne uygulayın. İşlemlerin her biri, O(1 + i) zamanda çalışmalıdır. Alıştırma 3.4. TBListe’nin, tüm elemanlarını ters yönde sıralayan, tersSırala() işlemini tasarlayın ve uygulayın. Bu işlem, O(n) za- manda çalışmalıdır; özyineleme, herhangi bir ikincil veri yapısı ve yeni düğümlerin oluşturulması gerekli değildir. Alıştırma 3.5. boyutKontrol() adında birer TBListe ve ÇBListe işlemini tasarlayın ve uygulayın. Bu işlem, liste elemanları üzerinden adım adım giderek, listede kayıtlı bulunan n değeri ile eşleşip eşleşmediğini, düğüm sayısını sayarak bulur. Döndürdüğü değer yoktur, ancak, hesapladığı boyut, n değeri ile eşleşmiyorsa, bir istisna fırlatır. 144| Alıştırma 3.6. önceyeEkle() işleminin kodunu, u düğümünü oluşturarak, w düğümünden hemen önce, ÇBListe’ye ekleyecek şekilde yeniden yazın. Bu bölümden alıntı yapmayın. Kodunuz tam olarak bu kitapta verilen kod ile eşleşmiyor olabilir. Bu, kodun doğru olmadığı anlamına gelmez. Çalışıp çalışmadığını test ederek görün. Bundan sonraki birkaç alıştırma, ÇBListe üzerinde yapılabilecek değişiklikleri içeriyor. Herhangi bir yeni düğüm veya geçici dizi tahsis etmeden, bunları tamamlamanız gerekiyor. Sadece mevcut düğümlerin, önceki ve sonraki değerlerini değiştirerek bu alıştırmaları yapabilirsiniz. Alıştırma 3.7. Liste bir palindrom olduğunda true döndüren palindromu() adında bir ÇBListe işlemini uygulayın. Her için, i konumundaki eleman, n – i – 1 konumunda- ki elemana eşit olmalıdır. Kodunuz O(n) zamanda çalışmalıdır. Alıştırma 3.8. ÇBListe elemanYerDeğiştir(r) elemanlarının yerlerini değiştiren, işlemini uygulayın. Bu işlemi uygularken, i konumundaki liste elemanının yeri, (i + r) mod n konumunda olacak şekilde yer değişmelidir. İşlem O(1 + min{r, n – r}) zamanda çalışmalıdır. Alıştırma 3.9. ÇBListe’nin i konumundan itibaren liste içeriğini kısaltan, içeriğiKısalt(i) işlemini uygulayın. Bu işlemi çalıştırdıktan sonra, listenin boyutu i olacak şekilde belirlenmeli, ve sadece 0,…,i – 1 endekslerinde bulunan elemanları içermelidir. i,…,n – 1 en- | 145 dekslerinde bulunan elemanları başka bir ÇBListe halinde döndürmelidir. İşlem O(min {i, n – i}) zamanda çalışmalıdır. Alıştırma 3.10. ÇBListe arayüzüne ait em(l2) işlemini uygulayın. Bu işlem, ÇBListe türünde l2 argümanını alır, ve bu listeyi temizleyerek sırasıyla içeriğini, onu çağıran listeye ekler. Örneğin, l1 elemanları a, b, c, ve l2 elemanları d, e, f olursa, l1.em(l2) çağrıldıktan sonra l1 içeriği a, b, c, d, e, f olarak ve l2 içeriği boş şekilde dönmelidir. Alıştırma 3.11. ÇBListe arayüzüne ait tekliEndeksElemanları() işlemini uygulayın. Bu işlem, listenin tek sayılı endekslerinde bulunan elemanları ortadan kaldırır ve bu elemanları bir başka ÇBListe halinde döndürür. Örneğin, l1 elemanları a, b, c, d, e, f olursa, l1.tekliEndeksElemanları() çağrıldıktan sonra l1 elemanları a, c, e olmalı ve elemanları b, d, f olan bir liste dönmelidir. Alıştırma 3.12. ÇBListe arayüzüne ait ters() işlemini uygulayın. Bu işlem, liste elemanlarını ters sırada yeniden yapılandırır. Alıştırma 3.13. Bu alıştırma, Birleştirerek-Sıralama Bölümü’nde tartışıldığı gibi, ÇBListe elemanlarını sıralayan bir birleştirmesıralama algoritmasının uygulamasını tanıtıyor. Elemanları karşılaştırmak için karşılaştır(x) işlemini kullanıyoruz, böylece Karşılaştırılabilir ÇBListe’yi arayüzünü uygulayan elemanları içeren herhangi sıralamak mümkündür. 146| 1. l2 ilkiniSeç(l2) adında bir ÇBListe işlemini uygulayın. Bu işlem, listesinin başında bulunan düğümü alır, ve alıcı listesine ekler. Boş bir liste ile başlanmadığı takdirde, bu işlem, ekle(boyut(), l2.sil(0)) çağrısının 2. ÇBListe eşdeğeri olan bir sonuç döndürür. arayüzüne ait, birleştir(l1, l2) statik işlemini uygula- yın. Bu işlem, l1 ve l2 sıralı listelerini birleştirir, ve sıralı yeni listeyi döndürür. Bu süreç sonunda l1 ve l2 listelerinin içeriği boş hale gelir. Örneğin l1 elemanları a, c, d ve l2 elemanları b, e, f olursa, bu işlem a, b, c, d, e, f içeren yeni bir liste döndürür. 3. Listenin elemanlarını birleştirme-sıralama algoritmasını kulla- narak sıralayan sırala() işlemini uygulayın. Özyinelemeli algoritma ile şöyle gerçekleştirebilirsiniz: a. Liste boyutu, 0 veya 1 eleman ise, hiçbir şey yapmayın. Diğer durumlarda, b. içeriğiKısalt(boyut() / 2) işlemini kullanarak listeyi yaklaşık olarak eşit uzunlukta olan iki listeye l1, l2 halinde bölün. c. Özyinelemeli olarak l1 listesini sıralayın. d. Özyinelemeli olarak l2 listesini sıralayın, ve en sonunda; e. l1, l2 listelerini tek sıralı liste halinde birleştirin. Sonraki birkaç alıştırma daha zordur. Yığıt veri yapısında depolanan minimum değere erişme, ekleme ve silme işlemleri sırasında Kuyruk’a neler olduğuna dair net bir anlayış gereklidir. Alıştırma 3.14. MinYığıt veri yapısına ait yığ(x), yığıttan_kaldır(), ekle(x), sil(), ve min() işlemlerini tasarlayın ve uygulayın. min() | 147 işlemi, halihazırda veri yapısında bulunan en küçük değere sahip elemanı döndürür. MinYığıt içinde depolanan elemanlar kıyaslanabilir özellikte olmalıdır. Bütün işlemler sabit zamanda çalışmalıdır. Alıştırma 3.15. MinKuyruk veri yapısına ait ekle(x), sil(), boyut(), ve min(x) işlemlerini tasarlayın ve uygulayın. min(x) işlemi, halihazırda veri yapısında bulunan en küçük değere sahip elemanı döndürür. MinKuyruk içinde depolanan elemanlar kıyaslanabilir özellikte olmalıdır. Bütün işlemler sabit amortize zamanda çalışmalıdır. Alıştırma 3.16. MinİkiBaşlıKuyruk veri yapısına ait ekleİlk(x), ekleSon(x), ilkiniSil(), sonuncuyuSil(), boyut(), ve min() işlemle- rini tasarlayın ve uygulayın. min() işlemi, halihazırda veri yapısında bulunan en MinİkiBaşlıKuyruk küçük değere sahip elemanı döndürür. içinde depolanan elemanlar kıyaslanabilir özel- likte olmalıdır. Bütün işlemler sabit amortize zamanda çalışmalıdır. Sonraki alıştırmalar, alan-verimli AVListe’nin uygulanması ve analizi hakkında okuyucunun anlayışını test etmek için hazırlanmıştır. Alıştırma 3.17. AVListe veri yapısı bir Yığıt gibi kullanılırsa, (böylelikle AVListe’ye tek değişiklik yığ(x) => ekle(boyut(), x), ve yığıttan_kaldır() => sil(size() – 1) olursa), bu işlemler b değerin- den bağımsız olarak, sabit amortize zamanda çalışır. 148| Alıştırma 3.18. İki Başlı Kuyruk işlemlerinin tümünü, b değerinden bağımsız olarak, işlem başına sabit amortize zamanda destekleyen bir AVListe versiyonunu tasarlayın ve uygulayın. Alıştırma 3.19. Sadece bitsel–veya işlecini, ^ kullanarak, iki int tamsayı değişken değerini, çüncü bir değişken kullanmadan nasıl değiş-tokuş edeceğinizi açıklayın. | 149 150| Bölüm 4 Sekme Listeleri Bu bölümde, çeşitli uygulamaları olan, biçimli bir veri yapısını tartışacağız: sekme listeleri. Liste veri yapısını kullanarak sekme listesini uyguladığınızda, al(i), belirle(i, x), ekle(i, x), ve sil(i) işlemlerini, O(log n) zamanda çalıştırabilirsiniz. Ayrıca Sıralı Küme uygulamasıyla, bütün işlemler O(log n) beklenen zamanda çalı- şır. Sekme listelerinin etkinliği, dayandığı rasgelelikten kaynaklanır. Yeni bir elemanı sekme listesine eklerken, elemanın yüksekliğini belirlemek için, rasgele yazı-tura atılır. Sekme listelerinin performansı, beklenen çalışma zamanları ve yol uzunlukları cinsinden ifade edilir. Bu beklenti, sekme listesi tarafından kullanılan rasgele yazı-tura fırlatışları üzerinden hesaplanır. Rasgele yazı-tura atma, yarı-rasgele sayı (veya bit) üretecini kullanarak gerçekleştirilir. | 151 Temel Yapı Kavramsal olarak sekme listesi, L0,…,Lh tekli-bağlantılı listelerden oluşan bir dizidir. Her Lr listesi Lr-1 listesinin içindeki elemanların bir alt kümesini içerir. n eleman içeren, L0 giriş listesi ile başlanır. Bunu takiben, L1 listesini L0 elemanlarından, L2 listesini L1 elemanlarından, ve buna benzer şekilde diğer listeleri oluştururuz. Lr listesinin elemanlarını oluştururken, Lr-1 listesinde bulunan her x elemanı için yazı-tura atılır. Yazı gelirse, x dahil edilir. Boş bir Lr listesi ile karşılaşıldığında süreç sonlanır. Örnek bir sekme listesi Şekil 4.1 'de gösterilmiştir. Sekme listesinin içinde yer alan bir x elemanının yüksekliği, bu elemanın bulunduğu Lr listesinin en büyük r değeri ile ölçülür. Buna göre, örneğin, sadece L0’da görünen elemanlar, 0 yüksekliğe sahiptir. Birkaç dakikamızı bu konuda düşünmeye ayırırsak, x'in yüksekliği aşağıdaki deney ile belirlenir: Tura gelene kadar ard arda yazı-tura atın. Kaç defa yazı geldi? Cevap, şaşırtıcı olmayacağı üzere, bir düğümün beklenen yüksekliği 1'dir (Tura gelmeden 152| önce iki kez yazı-tura atmayı bekliyoruz, ancak son atışı saymıyoruz). Bir sekme listesinin yüksekliği, en yüksek düğümünün yüksekliğidir. Her listenin başında, bu liste için bir dummy düğüm gibi davranan ve başlangıç olarak adlandırılan özel bir düğüm vardır. Sekme listelerinin anahtar özelliği, Lh listesinin başlangıcından L0 listesindeki tüm düğümlere, arama yolu olarak adlandırılan kısa bir yol olmasıdır. Bir u düğümü için arama yolunun nasıl düzenleneceğini hatırlamak kolaydır (bkz. Şekil 4.2): Sekme listesinin sol üst köşesinden (Lh listesinin başlangıcı) başlayın, ve u düğümünü aşmadığınız sürece her zaman sağa doğru gidin. Aşağıdaki listeye inip getirmeniz için, her seferinde aşağı yönde bir adım atmanız gerekir. Daha kesin bir ifadeyle, L0 listesi içindeki u düğümüne bir arama yolunu oluşturmak için, Lh listesinin w başlangıcından yola çıkarız. Sonra, w.next incelenir. Eğer w.next içinde L0 içindeki u düğümünden önce görünen bir eleman varsa, o zaman w = w.next olarak belirlenir. Aksi takdirde, bir alt listeye geçilir, ve Lh-1 listesinin w yerinden aramaya devam ederiz. L0 içindeki u düğümünün bir öncesine ulaşıncaya kadar, bu şekilde devam ediyoruz. | 153 Sekme Listelerinin Analizi Bölümü’nde ispat edeceğimiz aşağıdaki sonuç, arama yolunun oldukça kısa olduğunu göstermektedir: Önerme 4.1. L0 içindeki herhangi bir u düğümü için arama yolunun beklenen uzunluğu en fazla, 2log n + O(1) = O(log n) olarak hesaplanır. Bir sekme listesini gerçekleştirmenin alan-verimli yolu, veri değeri, x, ve bir işaretçi dizisi olan sonraki’ne sahip u düğümlerini tanım- lamaktır. u.sonraki[i], L1 listesi içinde, u düğümünden sonra gelene işaret etmelidir. Böylece, bir düğümdeki x verisi, birden fazla listede yer alsa bile, x sadece bir referansla depolanır. 154| Sonraki iki bölüm sekme listelerinin iki farklı uygulamasını tartışıyor. Bu uygulamaların her birinde, L0, ana yapıyı depolar (bir eleman listesi veya sıralı bir küme eleman). Bu yapılar arasındaki temel fark, bir arama yolu üzerinden nasıl yol alındığıdır; özellikle Lr-1’e inileceği mi, yoksa Lr içinde sağa doğru mu gidileceği konu- sunda karar vermede ayrılık gösterirler. | 155 Sıralı Küme Sekme Listesi: Verimli bir Sıralı Küme Sıralı Küme Sekme Listesi, Sekme Listesi Sıralı Küme veri yapısını kullanarak arayüzünü uygular. L0 listesi Sıralı Küme elemanlarını sıralı bir şekilde depolamaya yarar. bul(x) işlemi y ≥ x olan en küçük y değeri için, arama yolunu izler. y için arama yolunu izlemek kolaydır: Lr içinde bir u düğümüne rastladığımızda, sağdaki u.next[r].x verisine dikkat ederiz. Eğer x > u.next[r].x ise, Lr içinde sağa doğru bir adım atarız; aksi takdir- de, Lr-1 yönünde aşağı doğru hareket ederiz. Bu arama sırasında atılan her adım (sağa veya aşağı doğru) sadece sabit zaman alır; böylece, Önerme 4.1 ile, bul(x) işlemi O(log n) beklenen çalışma zamanında çalışır. 156| Bir eleman eklemeden önce yeni bir düğümün yüksekliği olan, k, Sıralı Küme Sekme Listesi tarafından hesaplanmalıdır. Bu amaçla yazı-tura atmak için bir işlem bulunmalıdır. Bir rasgele tamsayı, z, seçerek bunu yapabiliriz. Bunun için, ikili moddaki z sayısının sondan gelen 1 bitleri sayılır: Sıralı Küme Sekme Listesi içinde ekle(x) işlemini uygulamak için önce x aranır, ve yükseklikSeç() işlemi kullanılarak k belirlenir. Bunu takiben L0,...,Lk listeleri x için uç uça birbirine bağlanır. Bunu yapmanın en kolay yolu, arama yolunun Lr listesinden Lr-1 listesine indiği düğümlerin izlerini kaydeden bir Dizi Yığıt kullanmaktır. Daha kesin bir ifadeyle, yığıt[r], arama yolunun Lr-1 listesine indiği Lr düğümüdür. x eklenirken değiştirilen düğümler, tam olarak, yığıt[0]…yığıt[k] tarafından kaydedilir. | 157 x elemanını silmek benzer şekilde yapılır, ancak burada arama yo- lunu takip etmek için yığıt’a gerek duyulmaz. Arama yolu takip edilirken, aynı anda silme yapılabilir. x elemanını bulmak için yapılan arama sırasında, bir u düğümünden aşağıya doğru yapılan her harekette, u.next.x = x eşitliği kontrol edilir; sağlanması durumunda, u bir sonraki düğüme listenin dışına doğru uç uça bağlanır. 158| | 159 Özet Aşağıdaki teorem Sıralı Küme kullanılarak gerçekleştirilen Sekme Listesi’nin performansını özetlemektedir: Teorem 4.1. Sıralı Küme Sekme Listesi, Sıralı Küme arayüzünü uygular. Sıralı Küme Sekme Listesi, işlem başına O(log n) beklenen zamanda çalışan ekle(x), sil(x) ve bul(x) işlemlerini destekler. 160| Liste Sekme Listesi: Verimli Rasgele Erişim Listesi Liste Sekme Listesi, Liste bir Sekme Listesi veri yapısını kullanarak arayüzünü uygular. Liste Sekme Listesi’nde, L0 listesi, ele- manları listede göründükleri sırayla depolar. Sıralı Küme Sekme Listesi’nde olduğu gibi, elemanlar O(log n) zamanda eklenir, çıka- rılır ve erişilebilir. Bunun mümkün olabilmesi için, i'nci elemana erişmek için gerekli arama yolunu takip etmemiz için bir yol bulmamız gerekir. Bunu yapmanın en kolay yolu herhangi bir Lr listesi için kenar uzunluğu kavramını tanımlamaktır. L0 içindeki her kenarın uzunluğu 1 olarak tanımlanır. r > 0 olacak şekilde Lr listesindeki, e kenarının uzunluğu Lr-1 içindeki e kenarının altında yer alan uzunlukların toplamı olarak tanımlanmaktadır. Aynı anlama gelecek şekilde, e uzunluğu e altında yer alan L0 kenarlarının sayısıdır. Kenar uzunluklarının gösterildiği bir sekme listesi örneği için bkz. Şekil 4.5. Sekme listelerinin kenarları dizilerde depolandığı için, uzunlukları aynı şekilde depolanabilir. | 161 Bu uzunluk tanımının kullanışlı bir özelliği, eğer şu anda L0 içinde j pozisyonunda yer alan düğümde bulunuyorsak, ve l uzunluğunda bir kenarı izliyorsak, L0 içinde j + l konumundaki bir düğüme ulaşabiliriz. Bu şekilde, bir arama yolunu takip ederken, L0 içindeyken bulunduğumuz düğümün j pozisyonunu takip edebiliriz. Lr içindeki bir u düğümünde isek, j + u.next[r] kenarının uzunluğu i’den küçükse, sağa doğru gideriz. Aksi takdirde, Lr-1 içinde aşağı doğru gideriz. 162| al(i) ve belirle(i, x) işlemlerinin en zor kısmı, L0 içindeki i’nci dü- ğümü bulmak olduğu için, bu işlemler O(log n) zamanda çalışır. Liste Sekme Listesi içindeki i konumuna bir eleman eklemek ol- dukça kolaydır. Sıralı Küme Sekme Listesi’nin aksine, burada yeni bir düğümün muhakkak ekleneceğinden eminiz. Ekleme, yeni düğümün konumunu ararken aynı zamanda gerçekleştirilebilir. Önce yeni eklenen w düğümünün yüksekliği olan k seçilir, ve sonra i için arama yolu izlenir. Ne zaman ki arama yolu, r ≤ k olmak üzere, Lr ’dan aşağı doğru giderse, w için Lr uç uça birleştirilir. Sadece kenar | 163 uzunluklarının düzgün olarak güncellendiğinden emin olmak için özen göstermemiz gerekiyor. Bkz. Şekil 4.6. Unutmayın ki, Lr içindeki bir u düğümünden itibaren başlayan arama yolu, ne zaman aşağı doğru giderse, u.next [r] kenar uzunluğu 1 artırılır, çünkü i konumundaki kenarın altına yeni bir eleman ekliyoruz. w düğümü için listelerin u ve z olarak uç uça birleştirilmesi, Şekil 4.7’de gösterildiği gibi çalışır. Arama yolu takip edilirken L0 içindeki u düğümünün j pozisyonu takip edilmektedir. Bu ne- denle, u düğümünden w düğümüne kenar uzunluğunun i – j olduğunu biliyoruz. Bunun yanı sıra, aynı zamanda, w düğümünden z düğümüne uzanan kenar uzunluğunu, u düğümünden z düğümüne kenar uzunluğu olan l’ye bakarak çıkarsayabiliriz. Bu nedenle, listeler w için uç uça birleştirilir ve kenar uzunlukları sabit zaman içinde güncellenir. 164| Kod oldukça basit olduğu için, bu anlatılanlar size olduğundan daha karmaşık gelmiş olabilir: Artık, Liste Sekme Listesi’nde sil(i) işleminin gerçekleştirimi açık hale geldi. Düğüm için, i konumundaki arama yolu izlenir. Arama yolu, bir u düğümünden aşağı r seviyesinde her adım attığında, u | 165 aynı seviyede kalacak şekilde kenar uzunluğu azaltılır. Aynı zamanda, u.next[r] değerinin i’yi gösterip göstermediği kontrol edilir, ve gösteriyorsa listeler o seviyede uç uça birleştirilir. Bir örnek Şekil 4.8'de gösterilmiştir. 166| | 167 Özet Aşağıdaki teorem Liste Sekme Listesi veri yapısının performansını özetlemektedir: Teorem 4.2. Liste Sekme Listesi, Liste arayüzünü uygular. Liste Sekme Listesi, işlem başına O(log n) beklenen zamanda çalışan al(i), belirle(i, x), ekle(i, x) ve sil(i) işlemlerini destekler. 168| Sekme Listelerinin Analizi Bu bölümde, Sekme Listesi içindeki arama yolunun beklenen yüksekliği, boyutu ve uzunluğunu analiz edeceğiz. Bu bölüm, temel olasılık konusunda bir miktar bilgi birikiminizin var olmasını gerektirir. Yazı-tura atma ile ilgili aşağıdaki gözlem, çeşitli kanıtlamalar için bir temel oluşturmaktadır. Önerme 4.2. T adil bir paranın fırlatıldıktan sonra ilk defa yazı geldiği zamana kadar olan atma sayısı olsun. O zaman E[T] = 2 olarak hesaplanır. Kanıt. İlk defa yazı geldiği zaman yazı-tura atmayı durduğumuzu düşünelim. Gösterge değişkeni tanımlayın: Unutmayın ki, ancak ve ancak ilk i – 1 yazı-tura sonucu yazı geldiği takdirde, Ii=1 sağlanır, bu nedenle, olarak hesaplanır. Gözlemlemelisiniz ki, T, toplam yazı-tura atma sayısı ile verilir. Bu nedenle, | 169 Sonraki iki önerme, sekme listelerinin doğrusal boyutta olduğunu bize anlatıyor: Önerme 4.3. n eleman içeren bir sekme listesinin başlangıç düğümleri dışında kalan beklenen düğüm sayısı 2n olarak hesaplanır. Kanıt. Belirli bir x elemanının, Lr listesi tarafından depolanma olasılığı 1 / 2r, bu nedenle, Lr içindeki düğümlerin beklenen sayısı n / 2 r olarak hesaplanır. Böylece, tüm listelerde bulunan düğümle- rin beklenen toplam sayısı, Önerme 4.4. n eleman içeren bir sekme listesinin beklenen yüksekliği, log n + 2 olarak hesaplanır. 170| Kanıt. Her için gösterge rasgele değişkenini aşa- ğıdaki gibi tanımlayın: Sekme listesi yüksekliği, h, olarak verilir. Unutmayın ki, Ir değeri Lr uzunluğu olan |Lr|’dan asla daha fazla olamaz, bu nedenle, olarak hesaplanır. Aşağıdaki hesaplama kanıtı tamamlar: | 171 Önerme 4.5. Tüm başlangıç düğümlerinin de içerildiği, n elemanı depolayan bir 2n + O(log n) sekme listesinin beklenen düğüm sayısı, olarak hesaplanır. Kanıt. Önerme 4.3 ile belirtilmiştir ki, başlangıç düğümleri dışında kalan düğümlerin beklenen sayısı 2n olarak hesaplanır. Başlangıç düğümlerinin sayısı sekme listesinin yüksekliği olan, h, ile verilir. Böylece Önerme 4.4 ile belirtilmiştir ki, başlangıç düğümlerinin beklenen sayısı en fazla log n + 2 = O(log n) olarak hesaplanır. Önerme 4.6. Bir sekme listesinin beklenen arama yolu uzunluğu en fazla 2 log n + O(1) olarak hesaplanır. Kanıt. Bunu görmek için en kolay yol, bir x düğümü için ters arama yolunu ele almaktır. Bu yol L0 içindeki x düğümünden önce gelen düğümle başlar. Zamanla herhangi bir noktada, eğer yol bir seviye yukarı gidebilirse, gider. Bir seviye yukarı çıkamıyorsa o zaman sola doğru gider. Birkaç dakika için düşünülürse, bu ters arama yolunun, ters olması dışında x için arama yolu ile aynı olması anlaşılır. Belirli bir r seviyesinde, ters arama yolu tarafından ziyaret edilen düğümlerin sayısı aşağıdaki deney ile ilgilidir: Yazı-tura atın. Yazı gelirse, yukarı doğru gidin ve durun. Aksi takdirde, sola doğru hareket edin ve deneyi tekrarlayın. Yazı gelmeden önceki yazı-tura atma sayısı, bir ters arama yolunun, belirli bir seviyede sola doğru 172| attığı adımların sayısını temsil eder. Önerme 4.2, ilk defa yazı gelmeden önceki beklenen yazı-tura atma sayısının 1 olduğunu bildirmiştir. r seviyesinde ileri yöndeki arama yolunun sağa doğru attığı adım sayısının Sr ile gösterildiğini düşünelim. Az önce tartışıldığı gibi, E[Sr] ≤ 1. Ayrıca, Lr içinde Lr uzunluğundan daha fazla adım atamayacağımıza göre, Sr ≤ |Lr|, bu nedenle, Böylece şimdi, Önerme 4.4.’ün kanıtında olduğu gibi, bitirebiliriz. Sekme listesindeki bir u düğümü için arama yolunun uzunluğu S, ve sekme listesinin yüksekliği h olsun. Bu durumda, | 173 Aşağıdaki teorem bu bölümdeki sonuçları özetlemektedir: Teorem 4.3. n eleman içeren bir sekme listesinin beklenen boyutu O(n) ve herhangi bir eleman için arama yolunun beklenen uzunlu- ğu en fazla 2log n + O(1) olarak hesaplanır. 174| Tartışma ve Alıştırmalar Sekme listeleri Pugh [62] tarafından, uygulama ve uzantıları [61] dahil olmak üzere tanıtılmıştır. O tarihten bu yana yoğun çalışmalar yapılmıştır. Çeşitli araştırmacılar i’nci eleman için arama yolunun beklenen uzunluğu ve değişkenleri üzerine çok detaylı analizler yapmıştır [45, 44, 58]. Deterministik [53], taraflı [8, 26], ve kendini belirleyen sekme listeleri [12] geliştirilmiştir. Sekme listeleri uygulamaları çeşitli diller ve çerçeveler için yazılmıştır ve açık kaynak veritabanı sistemlerinde kullanılmaktadır [71, 63]. Sekme listelerinin bir benzeri HP-UX işletim sistemi çekirdeğinin süreç yönetim yapılarında kullanılmaktadır [42]. Sekme listeleri aynı zamanda Java API 1.6 [55] versiyonunun bir parçasıdır. Alıştırma 4.1. Şekil 4.1'deki sekme listesi üzerinde 2.5 ve 5.5 elemanları için arama yollarını gösterin. Alıştırma 4.2. Şekil 4.1'deki sekme listesi üzerinde 0.5 (1 yüksekliğe sahip) ve 3.5 (2 yüksekliğe sahip) değerlerinin toplamasını gösterin. Alıştırma 4.3. Şekil 4.1'deki sekme listesi üzerinde 1 ve 3 değerlerinin silinmesini gösterin. Alıştırma 4.4. Şekil 4.5’deki Liste Sekme Listesi üzerinde sil(2) işleminin çalıştırılmasını gösterin. | 175 Alıştırma 4.5. Şekil 4.5’deki Liste Sekme Listesi üzerinde ekle(3, x) işleminin çalıştırılmasını gösterin. Varsayın ki, yeni oluşturulan düğüm için yükseklikSeç() fonksiyonu yükseklik değeri olarak 4 seçsin. Alıştırma 4.6. ekle(x) ve sil(x) işlemleri sırasında Liste Sekme Listesi içindeki değişen işaretçilerin beklenen sayısının sabit oldu- ğunu gösterin. Alıştırma 4.7. Diyelim ki, bir elemanı yazı-tura atışımızın sonucuna göre Li-1 listesinden Li listesine geçirmek yerine, bunu p 1. Bu değişiklik ile, bir arama yolunun beklenen uzunluğunun en fazla 1 olan p olasılığı ile gerçekleştiriyoruz. 0 olduğunu gösterin. 2. Önceki ifadeyi minimize eden p değeri nedir? 3. Sekme listesinin beklenen yüksekliği nedir? 4. Sekme listesinin beklenen düğüm sayısı nedir? Alıştırma 4.8. Sıralı Küme Sekme Listesi bul(x) işlemi bazen gereksiz karşılaştırmalar gerçekleştirir; x aynı değerle kıyaslandığında bunlar oluşabilir. Bir u düğümü için u.next [r] = u.next [r - 1] olduğunda bunlar oluşur. Bu gereksiz karşılaştırmaların nasıl oluştuğunu gösterin, ve oluşmalarını engellemek için bul(x) gerçekleştiriminde değişiklikler yapın. Değiştirilmiş bul(x) işlemi tarafından yapılan karşılaştırmaların beklenen sayısını analiz edin. 176| Alıştırma 4.9. Sıralı Küme arayüzünü uygulayan, ama aynı zamanda derecesine göre elemanlara hızlı erişim sağlayan bir sekme listesi versiyonunu tasarlayın ve uygulayın. Bu veri yapısı, i dereceli elemanı döndüren al(i) fonksiyonunu, O(log n) beklenen zamanda çalıştırmalıdır (Sıralı Küme’de yer alan bir x elemanının derecesi x değerinin altındaki eleman sayısıdır). Alıştırma 4.10. Bir sekme listesinde parmak, arama yolunun indiği arama yolu üzerindeki düğüm sırasını depolayan bir dizi olarak tanımlanır (bu bölümdeki ekle(x) kodundaki yığıt değişkeni bir parmaktır; Şekil 4.3'deki kırmızı ile boyalı düğümler parmak içeriğini göstermektedir). Bir parmağın en alttaki, L0 listesindeki bir düğüme ait arama yoluna işaret ettiğini düşünebilirsiniz. Parmak araması, u.x < x ve (u.next = null veya u.next.x > x) olan bir u düğümüne ulaşana kadar, listeden yukarı doğru yürüyerek parmağı kullanır, ve sonra u düğümünden başlayarak, x için normal bir arama yaparak bul(x) işlemini uygular. L0 içinde depolanan x, ve parmak ile işaret edilen değer arasındaki sayı değerleri r ise, bir parmak araması için gerekli adımların beklenen sayısının O(1 + log r) olduğunu kanıtlamak mümkündür. Sekme Listesi’nin bul(x) bir alt sınıfı olan ve içsel bir parmak kullanarak işlemini uygulayan Parmak İle Sekme Listesi’ni gerçekleş- tirin. Bu alt sınıf, daha sonra her bul(x) işlemini bir parmak araması olarak gerçekleştiren bir parmak depolar. Her bul(x) işlemi sırasında başlangıç noktası olarak, önceki bul(x) işleminin sonucuna işa- | 177 ret eden bir parmak kullanılacak şekilde parmak güncelleştirilmesi yapılır. Alıştırma 4.11. Liste Sekme Listesi’nin i pozisyonunda liste içeriğini kısaltan içeriğiKısalt(i) adında bir işlem uygulayın. Bu işlemi çalıştırdıktan sonra, listenin boyutu i olacak şekilde belirlenmeli ve sadece 0,…,i – 1 endekslerinde bulunan elemanları içermelidir. i,…,n – 1 endekslerinde bulunan elemanları içeren bir başka Liste Sekme Listesi döndürmelidir. İşlem O(log n) zamanda çalışmalı- dır. Alıştırma 4.12. Liste Sekme Listesi arayüzüne ait em(l2) işlemini uygulayın. Bu işlem Liste Sekme Listesi türünde bir l2 argümanı olarak alır, bu liste elemanlarını temizleyerek, sırasıyla içeriğini onu çağıran listeye ekler. Örneğin, l1 elemanları a, b, c ve l2 elemanları d, e, f olursa, l1.em(l2) çağrısı yapıldıktan sonra l1 içeriği a, b, c, d, e, f ve l2 içeriği boş olarak döndürülmelidir. Bu işlemin çalışma zamanı O(log n) olmalıdır. Alıştırma 4.13. Alan Verimli Liste, AVListe fikirlerinden yola çıkarak, ve Sıralı Küme veri yapısını kullanarak, Alan Verimli Sıralı Küme, AVSKüme’yi tasarlayın ve uygulayın. Bunu gerçekleştirmek için, veri elemanlarını sıralı bir şekilde AVListe’de, ve AVListe bloklarını da Sıralı Küme’de depolayın. Orijinal Sıralı Küme uygulaması, n elemanı saklamak için, O(n) alan kullanıyorsa, AVSKüme, n O(n/b + b) eleman için yeterli olan alanı ve buna ek olarak miktarında bir alan kullanacaktır. 178| Alıştırma 4.14. Temel yapı olarak, Sıralı Küme kullanarak (büyük) bir metin dosyasını okuyan ve metinde yer alan herhangi bir alt dize için, etkileşimli arama yapmanızı sağlayan bir uygulama tasarlayın ve uygulayın. Kullanıcı sorgusunu yazdıkça, eş metnin parçası, eğer varsa, sonuçta görünmelidir. İpucu 1: Her altdize bazı sonek’in önekidir. Bu nedenle metin dosyasının tüm sonek’lerini depolamak yeterlidir. İpucu 2: Herhangi bir sonek, kısa ve etkili bir şekilde, ek’in metinde nerede başladığını gösteren bir tamsayı ile temsil edilebilir. Gutenberg Projesinde [1] mevcut kitaplardan bazılarında yer alan büyük metinler üzerinde uygulamanızı test edin. Eğer doğru uygulanırsa, tuş vuruşlarını yazarken hiçbir gecikme olmadan sonuçları görebilmelisiniz. Alıştırma 4.15 (Bu alıştırma Serbest Yükseklikli İkili Arama Ağacı Bölümü’ndeki ikili arama ağaçları konusu okunduktan sonra yapılmalıdır). İkili arama ağaçları ile sekme listelerini aşağıdaki şekillerde karşılaştırın: 1. Bir sekme listesinin bazı kenarları silindiğinde, ikili ağaç gibi görünen ve ikili arama ağacına benzer bir yapı haline nasıl dönüştüğünü açıklayın. | 179 2. Sekme listeleri ve ikili arama ağaçlarının her ikisi de yaklaşık aynı sayıda (düğüm başına 2) işaretçi kullanıyor. Oysa ki, sekme listeleri bu işaretçilerden daha iyi yararlanmaktadır. Neden? Açıklayın. 180| | 181 Bölüm 5 Karma Tabloları Karma tabloları, geniş bir U = {0,…,2w – 1} kümesinden az sayıda n tamsayısını depolamak için etkili bir yöntemdir. Karma tablosu terimi, geniş bir yelpazedeki çeşitli veri yapılarını içerir. Bu bölümde, karma tablolarının en yaygın bir uygulaması olan, zincirleme ile karma yöntemi üzerinde duracağız. Çok sıklıkla, karma tabloları, tamsayı olmayan veri türlerini içerir. Bu durumda, her veri elemanı, ayrı bir tamsayı karma kodu ile ilişkilendirilerek tabloda kullanılır. Bu gibi karma kodların nasıl oluşturulduğunu bölümün ikinci kısmında tartışacağız. Kullanılan bazı yöntemler, belirli bir aralıktaki tamsayılar arasından rasgele seçim yapmamızı gerektirir. Verilen kod örneklerinde, bu "rasgele" tamsayılar, hava seslerinden oluşturulan rasgele bitler kullanılarak elde edilen, kodlanmış sabitler olacaktır. 182| Zincirleme Karma Tablo: Zincirleme İle Adresleme Zincirleme Karma Tablo veri yapısı, zincirleme ile karma yöntemi- ni kullanarak, verileri, t listelerinden oluşan bir dizi halinde depolar. n tamsayısı, tüm listelerdeki toplam eleman sayısını tutar (bkz. Şekil 5.1): x veri elemanının karma değeri hash(x) ile belirtilir, ve {0,…,t.uzunluk – 1} aralığından bir değerdir. i karma değerine sahip tüm elemanlar listede t[i] konumunda depolanır. Liste uzunluğunu çok büyültmemek için şu değişmez geçerlidir: | 183 Böylece, bu listelerden birinde depolanan elemanların ortalama sayısı n/t.uzunluk ≤ 1 olarak hesaplanır. x elemanını karma tabloya eklemek için, önce t uzunluğunu artırıp artırmamak gerektiğini kontrol ederiz; gerekiyorsa artırırız. x karma kodu {0,…,t.uzunluk – 1} aralığında bulunan bir i tamsayısı ise, x elemanını t[i] listesine ekleriz. Tablonun büyültülmesi, gerekirse, t uzunluğunun iki katına çıkmasına, ve tüm elemanların yeni tabloya yeniden eklenmesine yol açar. Bu strateji, Dizi Yığıt uygulamasında kullanılan strateji ile birebir örtüşmektedir. Sonuç aynıdır: Amortize büyültme maliyeti, ekleme işlemi için yapılan çağrılar üzerinden, sadece sabit zaman alır. (bkz. Önerme 2.1). Büyültmenin yanı sıra, Zincirleme Karma Tablo’ya yeni bir x değeri eklerken yapılan diğer bir çalışma, t[hash(x)] listesinin sonuna x elemanını eklemektir. Bölüm 2 veya 3 'de anlatılan herhangi bir Liste uygulaması için bu, sadece sabit zaman alır. 184| Karma tablodan x elemanını silmek için, önce t[hash(x)] listesi üzerinden ilerlenerek, x elemanı bulunur ve silinir. Bu işlem O(nhash(x)) zamanda çalışır, ni konumu, t[i] listesinde depolanmış listenin uzunluğunu tutar. Karma tabloda x elemanı için arama yapmak benzer bir işlemdir. t[hash(x)] listesinde doğrusal bir arama gerçekleştirilir: Bu işlem de yine, t[hash(x)] listesinin uzunluğu ile orantılı zamanda çalışır. | 185 Karma tablosunun performansı, hash fonksiyonunun seçimi ile kritik olarak belirlidir. İyi bir karma fonksiyonu, elemanları t.uzunluk liste arasında eşit olarak dağıtır, böylece t[hash(x)] liste- sinin beklenen boyutu O(n/t.uzunluk) = O(1) olarak hesaplanır. Diğer taraftan, kötü bir hash fonksiyonu tüm değerleri (x içinde olmak üzere) aynı tablo konumuna karma yapacaktır, bu durumda, t[hash(x)] listesinin boyutu n olacaktır. Bir sonraki bölümde iyi bir karma fonksiyonunu tanımlayacağız. 186| Çarpımsal Karma Yöntemi Karma değerlerini oluşturmak için modüler aritmetiğe ve tamsayı bölünmesine dayanan (bkz. Dizi Kuyruğu: Dizi-Tabanlı Kuyruk Bölümü) çarpımsal karma, etkili bir yöntemdir. Bölümün tamsayı kısmını alan ve kalanı önemsemeyen div işlecini kullanır. Her tamsayı a ≥ 0 ve b ≥ 1 için, a div b = a/b olarak yazılabilir. Çarpımsal karma yöntemi, d, boyut belirten bir tamsayı ise, 2d boyutlu bir karma tablo kullanır. olan x tamsayısı için, karma formülü, olarak verilmiştir. Burada z, kümesinden rasgele seçilmiş bir tek tamsa- yıdır. w bir tamsayının bit sayısı olmak üzere, tamsayılar üzerindeki işlemler, varsayılan olarak, 2w modülo ile yapıldığı için, bu karma fonksiyonu, çok etkin bir şekilde uygulanabilir (bkz. Şekil 5.2). Ayrıca, tamsayının 2w – d ile bölünmesi ikili tabanda gösterimde en sağdaki w – d bitten kurtulmayı gerektirir (w – d biti sağa doğru kaydırınız). Böylece, yukarıdaki formülü uygulayan kod, formülün kendisinden daha kolay hale gelir: | 187 Aşağıdaki önerme, çarpımsal karmanın toslamalardan kaçındığını gösteriyor. Önerme 5.1. olmak üzere, 0,…,2w – 1 içindeki iki ayrı değer x ve y olsun, Kanıtını ertelediğimiz Önerme 5.1 ile, sil(x) ve bul(x) performanslarını analiz etmek kolaydır: Önerme 5.2. Herhangi x veri değeri için, t[hash(x)] listesinin beklenen uzunluğu en çok nx + 2 olarak hesaplanır. Karma tabloda x elemanının yinelenme sayısı nx ile verilmiştir. Kanıt. x’e eşit olmayan elemanların (çoklu)-kümesi S ile belirtilsin. yS için gösterge değişkenini tanımlayın. Unutmayın ki, Önerme 5.1. ile, t[hash(x)] listesinin beklenen uzunluğu, 188| ile verilir. Şimdi, Önerme 5.1’i kanıtlamak istiyoruz, ancak sayı kuramına ihtiyaç duymaktayız. Aşağıdaki kanıtta, sayısını belirt- mek için (br,…,b0)2 gösterimini kullanıyoruz. Burada her bi ikili tabanda 0 veya 1 bitleridir. Bir başka deyişle, (br,…,b0)2 ikili tabanda gösterimi br,…,b0 ile verilen bir tamsayıdır. Bilinmeyen değeri belirten bit için Önerme 5.3. kullanıyoruz. kümesindeki tek tamsayıların kümesi S olsun; S içindeki herhangi iki eleman q ve i olsun. Bu durumda, z S iken eşitliğini sağlayan sadece bir değer kesin olarak vardır. Kanıt. z ve i için eşit sayıda seçim yapılabileceği için, eşitliğini sağlayan en fazla bir adet z var olduğunu kanıtlamak yeterlidir. S değerinin | 189 Bir çelişkiyi denemek için, z z’ olmak üzere iki ayrı z ve z’ değeri olduğunu varsayalım. Bu nedenle, Bu eşitlik aynı şekilde k tamsayısı için yeniden yazılır: İkili tabanda gösterilen sayılar açısından düşünüldüğünde, Böylece (z – z’) q sayısının ikili gösteriminde sondan w bit 0 olarak hesaplanır. Ayrıca , ve olduğu için, doğrudur. q tek sayı olduğundan, ikili tabanda gösteriminin son biti 0 olamaz: olduğu için, z – z’ ikili tabanda gösterimi, w bitten daha az sayıda 0 bite sahiptir: 190| Bu nedenle, (z – z’)q çarpımının ikili tabanda gösterimi, w bitten daha az sayıda 0 bite sahiptir: Bu nedenle, (z – z’)q (5.1) eşitliğini sağlamaz; çelişki olarak hesaplanır. Şu gözlemden yararlanırsak, Önerme 5.3 daha iyi anlaşılacaktır: S içinden Z rasgele seçilirse, zt’nin S üzerindeki dağılımı normaldir. Aşağıdaki kanıtta, ikili tabanda z gösterimini w – 1 rasgele bitin ardından gelen 1 biti olarak düşünmek size yardımcı olacaktır. Önerme 5.1’in Kanıtı. Öncelikle unutmayın ki, hash(x) = hash(y) koşulu “zx mod 2w sonucunun en-yüksek dereceden d biti, ve zy mod 2 w sonucunun en-yüksek dereceden d biti aynıdır.” ifadesine eşdeğerdir. Bu açıklamanın gerekli koşulu z(x – y) mod 2w sayısının ikili tabanda gösteriminin en yüksek dereceden d biti, ya hep 0, ya hep 1 olmalıdır. zx mod 2w veya, zx mod 2w zy mod 2w iken, zy mod 2w iken, | 191 olur. Bu nedenle, z(x – y) mod 2w olasılığını (5.2) veya (5.3)’teki bağıntılarla ilişkilendirmemiz gerekiyor. Q, herhangi bir r tamsayısı için . koşulunu sağ- layan benzersiz bir tek tamsayı olsun. Önerme 5.3 ile, sayısının ikili tabanda gösterimi, w – 1 rasgele bitin ardından gelen bir 1 biti içerir: Bu nedenle, sayısının ikili tabanda gösterimi, w – r – 1 rasgele bitin ardından gelen bir 1 biti, ve ardından gelen tümü 0 olan bitleri içerir: Kanıtı şimdi bitirebiliriz: Eğer r > w – d ise, sayı- sının en yüksek dereceden d biti, hem 0 ve hem 1’leri içerir, böylece sayısının (5.2) veya (5.3) gibi görünme olasılığı 0’dır. Eğer r = w – d ise (5.2) gibi olma olasılığı 0’dır, ancak (5.3) gibi görünme olasılığı 1/2d-1 = 2/2d olarak hesaplanır (çünkü b1,…,bd-1 = 1,…,1 doğrudur). Eğer r w – d ise, bw – r – 1,…, 192| bw – r – d = 0, …, 0, veya bw – r – 1,…,bw – r – d = 1,…,1 doğrudur. Bu durumlardan her birinin olasılığı, 1 / 2d, ve ayrışık oldukları için, her iki durumun olasılığı 2 / 2d olarak hesaplanır. | 193 Özet Aşağıdaki teorem Zincirleme Karma Tablo veri yapısının performansını özetlemektedir: Teorem 5.1. Zincirleme Karma Tablo, Sırasız Küme arayüzünü uygular. yeniden_boyutlandır() işlemi için yapılan çağrıların maliyeti önemsenmediği takdirde, Zincirleme Karma Tablo, işlem başına O(1) beklenen zamanda çalışan ekle(x), sil(x) ve bul(x) işlemlerini destekler. Başlangıçta, Zincirleme Karma Tablo elemanları boş değer taşırken, ekle(x) ve sil(x) işlemleri sıralı olarak m defa çağrılırsa, yeniden_boyutlandır() zamanda çalışır. işlemi için yapılan tüm çağrılar O(m) toplam 194| Doğrusal Karma Tablo: Doğrusal Yerleştirme Doğrusal Karma Tablo veri yapısında, i’nci listede hash(x) = i olan tüm x elemanlarını depolayan bir liste dizisi kullanılır. Alternatif olarak, açık adresleme ile elemanlar doğrudan, t, dizisi içindeki her konumda en fazla bir değer olacak şekilde depolanır. Bu yaklaşım, Doğrusal Karma Tablo tarafından uygulanmıştır. Bazı yerlerde, bu veri yapısı doğrusal yerleştirme ile açık adresleme olarak tanımlanmaktadır. Doğrusal Karma Tablo hash(x) = i ardında yatan ana fikir, x elemanını hash değeri ile, ideal olarak t[i] tablo konumunda de- polamaktır. Zaten orada var olan bir eleman depolandığı için, bu yapılamıyorsa, t[(i + 1) mod t.uzunluk] konumunda depolanması beklenir. Bu da mümkün değilse, t[(i + 2) mod t.uzunluk] konumu denenir, ve böylece, x için bir yer bulana kadar devam ederiz. t içinde depolanan üç tür girdi vardır: 1. veri değerleri: Sırasız Küme’de depolanan gerçek değerler. 2. null değerler: Hiçbir veri kaydı yapılmamış dizi konumlarında bulunan değerler. 3. del değerler: Daha önce veri kaydı yapılmış, ancak silinmiş değerler. | 195 Doğrusal Karma Tablo’nun eleman sayısını tutan n yanında, q sa- yacı 1.tür ve 3.tür elemanların sayısını belirtir. Bunun anlamı, n ve del değerlerini taşıyan elemanların toplam sayısı q olur. Bu işi ve- rimli hale getirmek için, t için ayrılan üst limitin, q değişkeninde tutulan değerden nispeten çok büyük olması gerekir. Böylece t içinde ayrılmış pek çok boş değer yeri olmalıdır. Bu nedenle, Doğrusal Karma Tablo üzerinde yapılan işlemler için t.uzunluk ≥ q değişmezini sağlar. Özetlemek gerekirse, veri elemanlarını depolamak için Doğrusal Karma Tablo, t dizisini kullanır; n ve q tamsayıları sırasıyla, veri elemanlarının sayısını ve null-olmayan t değerlerini belirtir. Birçok karma fonksiyonları sadece 2’nin kuvveti olan eleman sayısına kadar veri depolayabildiği için, tanımladığımız bir d tamsayısı ile t.uzunluk = 2 d değişmezini sağlayabiliriz. Doğrusal Karma Tablo hash(x) = i arayüzüne ait bul(x) işlemi basittir. olan t[i] dizi konumuyla başlarız. Sırasıyla t[i], t[(i + 1) mod t.uzunluk], t [(i + 2) mod t.uzunluk] konumları aranır, ve böylece, t[i’] = x, veya t[i’] = null koşullarından en az birini sağlayan bir i’ konumunu bulana kadar arama devam eder. Bir önceki durum sağlanmışsa, t[i’] elemanını döndürürüz. Sonraki 196| durum sağlanmışsa, karma tabloda x elemanının bulunmadığı sonucuna varırız ve null değer döndürürüz. ekle(x) işlemini uygulamak oldukça kolaydır. Tabloda x elemanı- nın henüz depolanıp depolanmadığını (bul(x) ile) kontrol ettikten sonra, null veya del değerlerini bulana kadar t[(i + 1) mod t.uzunluk], t[(i + 2) mod t.uzunluk] t[i], konumları aramaya devam ederiz. x elemanını, tam olarak bulduğumuz konuma dahil ederiz; q ve n sayılarını uygun şekilde güncelleriz. Şu andan itibaren, sil(x) işlemini uygulamak açık hale geldi. t[i’] = x veya t[i’] = null koşulunu sağlayan bir i’ endeksi bulana kadar, t[i], t[(i + 1) mod t.uzunluk], t[(i + 2) mod t.uzunluk] | 197 konumlarını aramaya devam ederiz. Bir önceki durum sağlanmışsa, t[i0] = del olarak belirler ve true döndürürüz. Sonraki durum sağ- lanmışsa, karma tabloda x elemanının bulunmadığı sonucuna varırız (bu nedenle x silinemez), ve false döndürürüz. bul(x), ekle(x) ve sil(x) işlemlerinin doğruluğunu del değerlerinin kullanımına bağlı olarak kolayca kanıtlayabiliriz. Bu işlemlerin hiçbiri, boş olmayan hiçbir girişe null değerini atayamaz. Bu nedenle, t[i’] = null olan i’ endeksine ulaşmak, mutlak şekilde x değerinin tabloda bulunmadığı anlamına gelir; ve yine aynı anlamda, t[i’] bundan önce de her zaman null değere sahipti, ve yine aynı şekilde, öncesinden çalıştırılan bir ekle(i’) işleminin, i’ konumundan ileri gitmesi için hiçbir sebep yoktur. 198| null olmayan girişlerin sayısı t.uzunluk/2 sayısından fazla hale geldiği zaman ekle(x) tarafından yeniden_boyutlandır() işlemi çağrılır. null olmayan girişlerin sayısı t.uzunluk/8 sayısından az hale geldiği zaman sil(x) tarafından yeniden_boyutlandır() işlemi çağrılır. Negatif olmayan en küçük d tamsayısı 2d ≥ 3n bulunur, t dizisi 2d boyutuna sahip olacak şekilde yeniden tahsis edilir, ve sonra eski dizide yer alan tüm elemanlar yeni boyutlu t dizisi içine tekrar yerleştirilir. Bunu yaparken, q eşittir n olarak belirlenir, çünkü yeni dizide hiçbir eleman del değerine sahip değildir. | 199 Doğrusal Yerleştirme Analizi Unutmayın ki, t dizisinde bulunan ilk null girişe ulaşıldığı zaman (veya bu endeksten öncesinde de olabilir), ekle(x), sil(x) ve bul(x) işlemleri sonlanır. Doğrusal yerleştirme analizinde temel mantık, t elemanlarının en az yarısı boş olduğu için, bir işlemin tamamlaması çok sürmez, çünkü hızlı bir şekilde null girişe ulaşılacaktır. Ancak bu mantık çok kuvvetli değildir, çünkü bize t boyutu hakkında, bir işlemin t içinde aradığı konum sayısının beklenen değerinin en fazla 2 olması gibi (yanlış) bir ipucu vermektedir. Bu bölümün geri kalanı için, karma değerlerin birbirinden bağımsız olarak 0,…,t.uzunluk – 1 aralığında düzgün dağıtıldığını kabul edeceğiz. Bu gerçekçi bir varsayım değildir, ancak doğrusal yerleştirmeyi analiz etmek için mümkün olan bir başlangıç noktası sağlar. İlerleyen bölümlerde, “Listeleme Karma” adında diğer bir yöntemi tanıtacağız. Bu yöntem, doğrusal yerleştirme için “yeterince uygun” bir karma fonksiyonunu oluşturur. t dizisindeki endekslerin tümünün t.uzunluk modüler aritmetiğinin sonucuna göre belirlendiğini varsayıyoruz (t[i mod t.uzunluk] için bir kısaltma t[i] ile verilmiştir). i konumundan başlayan k uzunluğundaki bir çalıştırmanın gerçek- leşmesi için, t[i], t[i + 1], … , t[i + k – 1] girişlerinin tümü null olmamalı, ve aynı zamanda t[i – 1] = t[i + k] = null olmalıdır. t içinde null olmayan elemanların sayısına q dersek, ekle(x) işlemi, 200| her zaman için q ≤ t.uzunluk / den_boyutlandır() 2 eşitsizliğini sağlar. yeni- işleminin en son çalıştırılmasından itibaren, diziye q eleman, x1,…,xq eklenmiştir. Varsayıyoruz ki, tablo elemanlarının her biri hash(xj) ile belirtilen, normal dağılımlı ve diğerlerinden bağımsız olan bir karma değer taşımaktadır. Bu plan ile, doğrusal yerleştirmeyi analiz etmek için gerekli ana önermeyi kanıtlamaya geçebiliriz. Önerme 5.4. i {0,…,t.uzunluk – 1} olsun. 0 c 1 sabiti ile k uzunluğunda i konumundan başlayan bir işlem O(ck) zamanda çalışır. Kanıt. Bir işlem, i konumundan başlayarak k uzunluğunda çalışırsa, hash(xj) koşulunu sağlayan tam olarak k adet {i,…,i + k – 1} eleman vardır. Bu durumun tam olarak olasılığı, olur, çünkü, k elemanın her permütasyonu için, bu k eleman k konumundan birine karma edilmeli, ve kalan q – k eleman tablo üzerinde kalan diğer t.uzunluk – k konumları için ayrılmalıdır. Faktöryel işlemler için yapılan aşağıdaki türetme sırasında r! ile (r/e) r yer değiştirilmiştir. Stirling'in Faktöryeller Bölümü) göre, bu küçük hile, Yaklaşımı’na (bkz. hata payı getirir. Bu, sadece çıkarımı kolaylaştırmak için yapılmıştır. Alıştırma 5.4 | 201 bütünüyle Stirling’in Yaklaşımı’nı kullanarak dikkatli bir hesaplama mantığı getiriyor. t.uzunluk değeri en küçükken, pk değeri en yüksektir. Veri yapısı, t.uzunluk ≥ 2q değişmezini sağladığı için, (Son adımda, her x kullanacağız). nır. 0 için doğru olan (1 + 1/x)x ≤ e eşitsizliğini olmasıyla kanıt tamamla- bul(x), ekle(x) ve sil(x) işlemlerinin beklenen çalışma zamanları için üst sınırları kanıtlamak, Önerme 5.4’ü kullanarak, şimdi kolay 202| ve açık hale geldi. Doğrusal Karma Tablo’da hiç depolanmamış bazı x değerleri için bul(x) işleminin çalıştırıldığını düşünelim. En kolay olan bu durumda, i = hash(x) değeri 0, t.uzunluk – 1 içinde t içeriğinden bağımsız ve rasgeledir. k uzunluğundaki çalıştırmanın bir parçası i ise, bul(x) işlemi en çok O(1 + k) zamanda çalışır. Böylece, beklenen çalışma zamanı, ile üst-sınırlanır. Unutmayın ki, k uzunluğundaki her çalıştırma, iç toplama k defa katkıda bulunur. Böylece, yapılan toplam katkıya k2 dersek, yukarıdaki toplamı tekrar şöyle yazabiliriz: Bu türetmenin son adımı, serisinin katlanarak aza- lan bir dizi olması gerçeğinden yola çıkmıştır. Bu nedenle, bul(x) | 203 işlemi, tabloda bulunmayan bir x değeri için O(1) beklenen zamanda çalışır. yeniden_boyutlandır() işleminin maliyeti önemsenmediği takdirde, yukarıdaki analiz, Doğrusal Karma Tablo işlemlerinin tümünün maliyetini analiz etmek için gerek duyduğumuz herşeyi bize veriyor. Birincisi, yukarıda verilen bul(x) analizi, x elemanı tabloda bulunmadığı zaman, ekle(x) işlemine uygulanabilir. x elemanı tabloda bulunuyorsa, bu maliyetin ekle(x) için yapılan analiz ile aynı sonucu ürettiğini unutmamalısınız. Son olarak, sil(x) işlemi de en üst seviyede bul(x) ile sınırlıdır. Özet olarak, yeniden_boyutlandır() için yapılan çağrıların maliyeti önemsenmediği takdirde, Doğrusal Karma Tablo işlemlerinin tümü O(1) beklenen zamanda çalışır. Dizi Yığıt veri yapısı için yapılan amortize analizin aynısını kullanarak yeniden boyutlandırmanın maliyeti hesaplanabilir. 204| Özet Aşağıdaki teorem Doğrusal Karma Tablo veri yapısının performansını özetlemektedir: Teorem 5.2. Doğrusal Karma Tablo, Sırasız Küme arayüzünü uygular. yeniden_boyutlandır() için yapılan çağrıların maliyeti önemsenmediği takdirde, Doğrusal Karma Tablo, işlem başına O(1) beklenen zamanda çalışan ekle(x), sil(x) ve bul(x) işlemleri- ni destekler. Başlangıçta, Doğrusal Karma Tablo elemanları boş değer taşırken, ekle(x) ve sil(x) işlemleri sıralı olarak m defa çağrılırsa, yeni- den_boyutlandır() işlemi için yapılan çağrı O(m) zamanda çalışır. | 205 Listeleme Karma Yöntemi Doğrusal Karma Tablo yapısını analiz ederken, çok güçlü bir var- sayımda bulunduk: Her {x1, …, xn} elemanına karşılık gelen hash(x1),…,hash(xn) karma değerleri {0,…,t.length – 1} kümesi üzerinde bağımsız ve düzgün dağıtılmıştır. Bunu elde etmenin bir yolu, 2w boyutunda çok büyük bir tab dizisi depolamaktır. Bu dizinin her girişi, tüm diğer kayıtlardan bağımsız olan, rasgele bir w-bit tamsayısı depolar. Böylece, tab[x.hashCode()] değerinden d-bit tamsayıyı ayıklayarak hash(x) fonksiyonunu uygulayabiliriz. Ne yazık ki, 2w boyutunda bir dizi depolamak, bellek kullanımı açısından pahalıdır. Bunun yerine, Listeleme Karma yaklaşımı, wbit tamsayıyı, her biri r bite sahip w/r tamsayı tarafından oluşuyormuş gibi işler. Böylece, her biri sadece 2r uzunluğunda, w/r adet diziye ihtiyaç duyulur. Bu dizilerdeki tüm kayıtlar bağımsız birer w-bit tamsayıdır. hash(x) karma değerini elde etmek için x.hashCode() değerini w/r adet r-bit tamsayıya böleriz ve bunları bu dizilere endeksler gibi kullanırız. Daha sonra hash(x) karma değerini elde etmek için tüm bu değerleri bitsel–veya–harici işleci ile birleştiririz. Aşağıdaki kod, w = 32 ve r = 4 olduğu zaman, bunun nasıl çalıştığını gösteriyor: 206| Bu durumda, tab, dört sütunlu ve 232/4 = 256 satırlı, iki boyutlu bir dizidir. Herhangi bir x için hash(x) değerinin {0,...,2d – 1} kümesi üzerinde düzgün dağıtıldığını kolayca doğrulayabilirsiniz. Küçük bir çalışma ile, herhangi iki karma değerinin birbirinden bağımsız olduğunu da doğrulayabilirsiniz. Bunun anlamı, listeleme karma yönteminin, Zincirleme Karma Tablo uygulaması için çarpımsal karma yönteminin yerine kullanılabilmesidir. Ancak, n farklı elemandan oluşan herhangi bir kümenin, n bağımsız karma değerini vereceği doğru değildir. Yine de, listeleme karma yöntemi kullanıldığında, Teorem 5.2 ile verilen sınırlar hala geçerlidir. Buna ait referanslar bölümün sonunda verilmiştir. | 207 Karma Kodları Önceki bölümde tartışılan karma tabloları, w bitten oluşan tamsayı anahtarlarını veri ile ilişkilendirmek için kullanılmıştı. Oysa ki, birçok durumda, tamsayı olmayan anahtarlar ile karşılaşırız. Anahtarlarımız dize, nesne, dizi, veya diğer bileşik yapılar olabilir. Karma tablosunda kullanmak üzere, bu veri türlerinin w-bit karma kodları ile eşleştirilmesi gerekir. Karma kodu eşleştirmeleri aşağıdaki özelliklere sahip olmalıdır: 1. x ve y eşit 2. x ise, x.hashCode() ve y.hashCode() eşittir. ve y eşit değil ise, x.hashCode() = y.hashCode() olasılığı küçük olmalıdır (yaklaşık 1/2w). Birinci özellik, eğer karma bir tabloda x elemanını depoluyorsak, ve daha sonra x’e eşit olan bir y değerini arıyorsak, x’i gerektiği gibi buluruz – koşulunu sağlar. İkinci özellik, nesneleri tamsayılara dönüştürmemizden gelen kaybı en aza indirir. Eşit olmayan nesnelerin genellikle farklı karma kodları vardır, ve böylece karma tablomuzda farklı yerlerde depolanmış olmaları muhtemeldir, koşulunu sağlar. 208| Temel Veri Türleri için Karma Kodları char, byte, int ve float gibi küçük temel veri türleri için karma kodlarını bulmak genellikle kolaydır. Bu veri türlerinin her zaman ikili gösterimi vardır ve bu ikili gösterim genellikle, w veya daha az bitten oluşur (Örneğin, Java’da byte 8-bitlik bir türdür ve float 32bitlik türdür). Bu durumlarda, bu bitleri sadece {0,…,2w – 1} aralığında bir tamsayının sembolü olarak görüyoruz. İki değer farklı ise, farklı karma kodları hesaplanır. Aynı iseler, aynı karma kodları olur. Birkaç temel veri türü, w bitten daha fazlasını içerir, veya bir c tamsayı sabiti için genellikle cw bitten oluşur.(Örnek olarak, Java long ve double türleri için c = 2 verilmiştir). Bir sonraki bölümde anlatıldığı gibi, bu veri türleri c bölümden oluşan bileşik nesneler olarak işlenebilir. | 209 Bileşik Nesneler için Karma Kodları Bir bileşik nesne için, nesneyi oluşturan parçaların tek tek karma kodlarını birleştirerek karma kodu oluşturmak istiyoruz. Bunu elde etmek göründüğü kadar kolay değildir. Pek çok çözüm yolu bulunabilmesine rağmen (örneğin, bitsel–veya–harici işlemleri ile karma kodlarını birleştirerek), bu yollardan çoğu kolaylıkla engellenebilir (bkz. Alıştırmalar 5.7 – 5.9). Ancak, 2w bit duyarlığında aritmetik yapmaya istekli iseniz, mevcut basit ve sağlam işlemler yapabilirsiniz. Birkaç bölümden, P0, ..., Pr-1, oluşan bir nesne olduğunu varsayalım. Bu bölümlerin karma kodları, sırasıyla, x0,…,xr-1 olsun. Karşılıklı bağımsız rasgele w-bit z0, …, zr-1 tamsayılarını ve rasgele 2w-bit tek z tamsayısını seçerek, nesnemiz için karma kodunu şöyle hesaplayabiliriz: Unutmayın ki, bu hash kodunun karma formülünü kullanan (z ile çarpan ve 2w ile bölen) bir son adımı vardır. Bu adım, 2w-bitlik ara sonucu alır, ve bunu w-bitlik bir son sonuç haline getirmek için Çarpımsal Karma Yöntemi Bölümü’nde verilen çarpımsal karma fonksiyonunu kullanır. 210| Bu yöntemin x0, x1, x2 bölümlerinden oluşan bileşik bir nesneye uygulanmış hali yukarıda verilmiştir. Aşağıdaki teorem göstermektedir ki, bu yöntem, uygulamasının açık olmasının yanı sıra, kanıtlanabilirlik açısından da iyidir. Teorem 5.3. x0,…,xr–1 ve y0,…,yr–1 tamsayıları, {0,…,2w – 1} içinde yer alan w bitlik birer dizi olsun, ve i {0,…,r – 1} en az bir i endeksi için varsayın ki, xi O zaman, yi. aralığından Kanıt. En sondaki çarpımsal karma adımını önemsemeyeceğiz, ve bu adımın katkısına daha sonra bakacağız. Tanımlayın: | 211 Diyelim ki, h’(x0,…,xr–1) = h’(y0,…,yr–1). Bunu şöyle yeniden yazabiliriz: Burada, olarak hesaplanır. Genelleştirme kaybı olmaksızın xi yi kabul edersek, (5.4) haline gelir, çünkü her bir zi ve (xi – yi) en fazla 2w – 1 olduğu için çarpımları en fazla 22w – 2w+1 + 1 22w – 1 olur. Varsayım olarak, xi – yi 0, bu nedenle (5.5) çözümü en çok bir tanedir. zi ve t ba- ğımsız olduğundan (z0,…,zr xr–1) = h’(y0,…,yr–1) – 1 karşılıklı bağımsızdır), h’(x0,…, koşulunu sağlayan bir zi seçme olasılığımız en fazla 1/2w olarak hesaplanır. Karma fonksiyonunun son adımı çarpımsal karma işlemini uygulayarak, 2w bitlik h’(x0,…,xr–1) ara sonucunu, son sonuç olan w bitlik h(x0,…,xr–1) haline getirmektir. Teorem 5.3 ile, eğer h’(x0,…,xr–1) h’(y0,…,yr–1) ise, Pr{h(x0,…,xr–1) = h(y0,…, yr–1)} olarak hesaplanır. 2/2 w 212| Özetlemek gerekirse, | 213 Diziler ve Dizeler için Karma Kodları Daha önceki bölümde anlatılan yöntem, değişmez, sabit sayıda bileşenler içeren nesneler için iyi çalışmaktadır. Ancak değişken sayıda bileşen içeren nesnelerle kullanmak istiyorsak, her bileşen için rasgele bir w-bit zi tamsayısı gerekir ki, yöntem bozulur. İhtiyacımız olduğu kadar zi oluşturmak için sözde rasgele bir dizi kullanabilirdik, ancak o zaman zi'lar birbirinden bağımsız olmazdı, ve sözde rasgele sayıların bizim kullandığımız karma fonksiyonu ile kötü etkileşimde olmadığını kanıtlamak zor hale gelirdi. Özellikle, Teorem 5.3 kanıtındaki t ve zi değerleri artık bağımsız değildir. Daha dikkatli bir yaklaşımla, karma kodlarını asal katsayılara sahip polinomlara dayandırabiliriz; bunlar bir, p, asal sayısı için modülo p üzerinden değerlendirilen normal polinomlardır. Bu yöntem, asal katsayılı polinomların hemen hemen her zamanki polinomlar gibi davrandığını söyleyen aşağıdaki teoreme dayanır: Teorem 5.4. p bir asal sayı, ve anlamlı bir polinomun, f(z) = x0z0 1 + x1z +…+ xr – 1 z r -1 , katsayıları xi rumda, f(z) mod p = 0 denkleminin z r–1 {0,…,p – 1} olsun. Bu du- {0,…,p – 1} için en fazla çözümü bulunur. Teorem 5.4’ü kullanmak için, her xi x0, …, xr–1 p – 1} {0,…,p – 2} olan bir tamsayı dizisini, rasgele bir z tamsayısını z {0,…, kullanarak, aşağıdaki formülle karma ederiz. 214| Formülün sonundaki ek terime, (p – 1)zr dikkat edin. Bu terim, x0,…,xr dizisinin son elemanı xr olarak (p – 1)’i düşünmemize yar- dımcı olarak hesaplanır. Unutmayın ki, bu eleman, dizideki diğer her elemandan (her biri {0,…,p – 2} kümesinde olan elemanlardan) farklıdır. p – 1, bir dizi-sonu-belirteci olarak da düşünülebilir. Aynı uzunluktaki iki dizi durumunu ele alan aşağıdaki teorem, bu karma fonksiyonunun z’yi seçmek için ihtiyaç duyulan az miktarda rasgelelik için iyi bir getiri sağladığını göstermektedir. Teorem 5.5. p yr–1 2 w + 1 asal sayı olsun. Her x0,…,xr–1 ve y0, …, tamsayısı, {0,…, 2w – 1} içinde yer alan w bitlik birer dizi olsun, ve i {0, …, r – 1} sayın ki, xi yi aralığından en az bir i endeksi için var- . O zaman, Kanıt. h(x0,…,xr–1) = h(y0,…,yr–1) denklemi yeniden şöyle yazılır: x1 y1 olduğundan bu polinom anlamsız değildir. Bu nedenle, Teo- rem 5.4 ile, z içinde en fazla r – 1 çözümü bulunur. Bu çözümlerden birinin z seçilmesi olasılığı, bu nedenle en fazla, (r – 1)/p olarak hesaplanır. | 215 Unutmayın ki, bu karma fonksiyonu, iki dizi farklı uzunluklara sahip olduğu zaman, ve dizilerden biri, diğerine önek olduğu zamanlar için de geçerlidir. Çünkü bu fonksiyon, etkin şekilde aşağıda belirtilen sonsuz diziye karma sağlar. r > r’ olan, r ve r’ uzunluğunda iki dizi varsa, bu iki dizi i = r en- deksinde farklılık gösterir. Bu durumda, (5.6) haline gelir. Teorem 5.4 ile, bu denklemin z içinde en fazla r çözümü bulunur. Teorem 5.5 ile birleştirildiğinde, aşağıdaki daha genel teoremi kanıtlamaya yeterlidir: Teorem 5.6. p yr’–1 w 2 +1 asal sayı olsun. Her x0, …, xr–1 ve y0, …, tamsayısı {0,…,2w – 1} içinde yer alan w bitlik birer dizi ol- sun. Bu durumda, Aşağıdaki örnek kod, bu karma fonksiyonun bir x dizisi içeren nesneye nasıl uygulandığını gösteriyor: 216| Yukarıdaki kod, uygulamada kolaylık sağlamak için, toslama olasılığını önemsememiştir. Özellikle, d = 31 ile x[i].hashCode() karma kodunu 31-bit değere indirmek için, Çarpımsal Karma Yöntemi Bölümü’ndeki çarpımsal karma fonksiyonunu uygulamıştır. Bu sayede, modülo p = 232 – 5 asal sayısı ile yapılan eklemeler ve çarpmalar 63-bit işaretsiz aritmetiği kullanılarak gerçekleştirilebilir. Böylece daha uzun olanın r uzunlukta olduğu iki farklı dizinin, aynı karma koduna sahip olma olasılığı, Teorem 5.6’da belirtilen r / (2 olur. 32 – 5) olacak yerde, en fazla, | 217 Tartışma ve Alıştırmalar Karma tabloları ve karma kodları, bu bölümde sadece değindiğimiz bir araştırmanın büyük ve aktif bir alanını temsil etmektedir. Karma üzerine yaklaşık 2,000 girdi içeren çevrimiçi Bibliyografya’ya [10]’dan erişebilirsiniz. Karma tablosu uygulamaları farklı ve çok çeşitlidir. Zincirleme Karma Tablo: Zincirleme İle Adresleme Bölümü'nde anlatılan yöntem zincirleme ile karma olarak bilinir. Her dizi girişi, bir zincir (Liste) içindeki elemanları içerir. Zincirleme ile karma tarihi, Ocak 1953’te H. P. Luhn tarafından hazırlanan IBM iç bildirisine kadar uzanmaktadır. Bu bildiri, bağlı listelere de ilk referanslardan biri olarak görünmektedir. Zincirleme ile karmaya bir alternatif de, tüm verilerin bir dizi içinde doğrudan depolandığı, açık adresleme şemaları tarafından kullanılan karmalardır. Bu şemalar, Doğrusal Karma Tablo: Doğrusal Yerleştirme Bölümü’ndeki Doğrusal Karma Tablo yapısını içerir. Bu fikir aynı zamanda bağımsız olarak 1950’lerde, IBM’deki bir grup tarafından önerilmişti. Açık adresleme şemaları, toslama çözümü sorunu ile, yani iki değerin aynı dizi konumuna karma olması durumuyla ilgilenmek zorundadır. Toslama çözümü için farklı stratejiler vardır; bunlar farklı performans garantisi sağlar, ve burada sık sık anlatılmış olanlardan daha gelişmiş karma fonksiyonlarını gerektirir. 218| Karma tablosu uygulamalarının bir başka kategorisi, mükemmel karma yöntemleri diye anılan kategoridir. Bu yöntemlerde bul(x) işlemi, en kötü O(1) zamanda çalışır. Statik veri kümeleri için, veriler üzerinde mükemmel karma fonksiyonları bulunarak bunu gerçekleştirmek mümkündür. Bu fonksiyonlar, her veri parçasını benzersiz bir dizi konumuyla eşleştirir. Zamanla değişen veriler için, mükemmel karma yöntemleri arasında, FKS iki-seviyeli karma tabloları [31, 24], ve guguk-kuşu karma yöntemi [57] sayılabilir. Bu bölümde sunulan karma fonksiyonları, muhtemelen her veri kümesi ile iyi çalışabilen bilinen en pratik yöntemlerdir. Diğer kanıtlanabilir yöntemler, Carter ve Wegman’ın evrensel karma kavramını tanıtan ve farklı senaryolar için çeşitli karma fonksiyonlarını anlatan öncü çalışmalarına [14] kadar uzanmaktadır. Listeleme Karma Yöntemi Bölümü'nde anlatılan listeleme karma, Carter ve Wegman tarafından açıklanmıştır [14], ancak doğrusal karma tabloya (ve diğer birçok karma tablo şemalarına) uygulanmış haliyle analizini Patraşcu ve Thorup’a [60] borçluyuz. Çarpımsal karma fikri çok eskidir, ve karma geleneğinin bir parçası gibi görünmektedir [48, bkz. Bölüm 6]. Ancak, z çarpanını rasgele bir tek sayı olarak seçme fikri, ve Çarpımsal Karma Yöntemi Bölümü’nde anlatılan analizi, Dietzfelbinger et al. [23] tarafından tartışılmıştır. Çarpımsal karmanın bu versiyonu, en basitlerinden biridir, ancak 2/2d olan toslama olasılığı, 2w 2 d ile belirtilen bir rasgele fonksiyondan beklediğinizden ikinin bir kuvveti kadar | 219 çok daha büyüktür. Çarpma-toplama karma yöntemi, z ve b rasgele olarak içinden seçilen, fonksiyonunu kullanır. Çarpma-toplama karmasının sadece 1/2d toslama olasılığı vardır [21], ancak 2w-bite duyarlı aritmetik gerektirir. Sabit uzunlukta olan w-bitlik tamsayı dizilerinden karma kodları elde etmenin yöntemleri vardır. Özellikle hızlı bir yöntem, çift sayı olan bir r, ve {0,…,2w} içinden rasgele seçilen a0, …, ar–1 değerleri için, fonksiyonunu [11] kullanmaktır. Bu 1/2w toslama olasılığı olan 2w-bitlik hash kodunu verir. Çarpımsal karma (veya çarpma- toplama) işlemini kullanarak, bunu, w-bitlik hash koduna indirebilirsiniz. Bu işlem hızlıdır, çünkü sadece r/2 adet 2w-bitlik çarpma gerektirir; oysa ki Bileşik Nesneler için Karma Kodları Bölümü’nde anlatılan işlem, r çarpma gerektiriyordu (mod işlemleri, eklemeler ve çarpmalar için, sırasıyla, w ve 2w-bit aritmetik kullanarak dolaylı olarak gerçekleştirilir). 220| Diziler ve Dizeler için Karma Kodları Bölümü’nde anlatılan, asal katsayılı polinomların, değişken uzunluktaki diziler ve dizelere karma edilerek kullanılması yöntemi, Dietzfelbinger ve arkadaşları [22] tarafından geliştirilmiştir. Pahalı bir makine komutuna dayanan mod işlecini kullanması nedeniyle, ne yazık ki, çok hızlı değildir. Bu işlemin bazı biçimleri, asal p olarak 2w – 1 seçer. Bu durumda mod işleci, ekleme (+) ve bitsel–ve (&) işlemi [47, Bölüm 3] ile yer değiştirebilir. Başka bir seçenek, sabit uzunluktaki dizeler için mevcut hızlı işlemlerden birini, c 1 sabitiyle verilen c uzun- luğundaki bloklara uygulamak, ve sonra asal katsayı yöntemini r/c karma kodlarından oluşan sonuç dizisine uygulamaktır. Alıştırma 5.1. Belirli bir üniversite, her öğrencisine herhangi bir kurs için ilk kez kayıt oldukları zaman birer öğrenci numarası veriyor. Yıllar önce 0 ile başlayan bu ardışık tamsayılar şimdi milyonları bulmuştur. Yüz adet birinci sınıf öğrencisine, öğrenci numaralarına dayalı karma kodlarını vermek istediğimizi düşünün. Bu durumda, öğrenci numarasının ilk iki basamağını mı, son iki basamağını mı kullanmak daha mantıklı olur? Cevabınızı doğrulayın. Alıştırma 5.2. Çarpımsal Karma Yöntemi Bölümü'nde verilen karma şemayı düşünün ve varsayalım ki, n=2d ve d ≤ w/2. 1. Seçilen herhangi bir z çarpanı için, hepsi aynı karma koduna ait, n değerin mevcut olduğunu gösterin (İpucu: Herhangi bir sayı teorisini gerektirmez). | 221 2. z çarpanı verildiğinde, hepsi aynı karma koduna ait, n değeri açıklayın (İpucu: Birtakım temel sayı teorisini gerektirir). Alıştırma 5.3. x=2w–d–2 ve y=3x ise Pr{hash(x)} = Pr{hash(y)} = 2/2 d olduğunu göstererek, Önerme 5.1 ile verilen 2/2d sınırının mümkün olan en iyi sınır olduğunu kanıtlayın (İpucu: İkili tabanda zx ve z3x gösterimlerine bakın, ve z3x = zx+2zx gerçeğini kulla- nın). Alıştırma 5.4. Faktöryeller Bölümü'nde verilen Stirling'in Yaklaşımı’nın tüm yorumunu kullanarak Önerme 5.4’ü tekrar kanıtlayın. Alıştırma 5.5. Bir Doğrusal Karma Tablo’ya x elemanını eklemek için, dizinin ilk null girdisine x elemanını depolayan kodun, aşağıdaki basitleştirilmiş versiyonunu düşünün. O(n) zamanda çalışan ekle(x), sil(x) ve bul(x) işlemlerini örnek vererek, bunun n2 zamanda neden çok yavaş çalışabileceğini açıklayın. 222| Alıştırma 5.6. String sınıfına ait Java hashCode() yönteminin önceki versiyonları, uzun dizelerde bulunan tüm karakterleri kullanmaksızın çalışıyordu. Örneğin, on altı uzunluğundaki karakter dizesi için karma kodu, yalnızca sekiz çift endeksli karakterleri kullanarak hesaplanmıştır. Hepsi aynı karma koduna sahip büyük miktarda dizeleri örnek göstererek, bunun neden çok kötü bir fikir olduğunu açıklayın. Alıştırma 5.7. Varsayalım ki, iki w-bit tamsayı olan x ve y’den oluşan bir nesne var. Neden x y fonksiyonu nesneniz için iyi bir karma kodu sağlamaz, gösterin. Karma kodu 0 olan nesnelerden oluşan büyük bir küme örneğini verin. Alıştırma 5.8. Varsayalım ki, iki w-bit tamsayı olan x ve y’den oluşan bir nesne var. Neden x + y fonksiyonu nesneniz için iyi bir karma kodu sağlamaz, gösterin. Karma kodu aynı olan nesnelerden oluşan büyük bir küme örneğini verin. Alıştırma 5.9. Varsayalım ki, iki w-bit tamsayı olan x ve y’den oluşan bir nesne var. Nesneniz için karma kodu, h(x, y) deterministik fonksiyonu ile tanımlansın. Bu fonksiyon, tek bir wbitlik tamsayı üretir. Aynı karma koduna sahip olan nesnelerin oluşturduğu büyük bir kümenin var olduğunu kanıtlayın. Alıştırma 5.10. Bazı pozitif tamsayı w için p=2w – 1 olsun. Neden bir pozitif tamsayı x için, | 223 olduğunu açıklayın. (x mod (2w – 1) hesabını gerçekleştiren bir algoritmada, x w 2 –1 olana dek, ard arda, olarak belirleyin). Alıştırma 5.11. Sık kullanılan bazı karma tablo uygulamalarını bulun (Java Collection Framework, HashMap veya bu kitapta yer alan Karma Tablo veya Doğrusal Karma Tablo uygulamaları gibi) ve bu veri yapısındaki tamsayıları depolayan bir program tasarlayın; öyle ki x tamsayıları için bul(x) işlemi, doğrusal zamanda çalışsın. Yani, n tamsayı içinden cn elemanın aynı tablo konumuna karma edildiği bir küme bulun. Uygulamanın ne kadar iyi olduğuna bağlı olarak, sadece uygulama kodunu inceleyerek bunu yapabilirsiniz, veya belirli değerleri eklemenin ve bulmanın ne kadar zaman aldığını belirlemek için, deneme mahiyetinde, ekleme ve arama işlemlerini gerçekleştiren bazı kodları yazmak zorunda kalabilirsiniz (Web sunucuları üzerinde bu, denial-of-service [17] saldırılarını başlatmak için kullanılabilir, ve kullanılmıştır). 224| Bölüm 6 İkili Ağaçlar Bu bölüm, bilgisayar bilimlerinin en temel yapılarından birini tanıtıyor: İkili Ağaç. Burada, köken olarak ağaç sözcüğünün kullanılması, kağıda çizdiğimizde, sık sık bir ormanda bulunan ağaca benzer şekilleri andırmasından ileri gelmektedir. İkili ağacı tanımlamanın birçok yolu vardır. Matematiksel olarak, ikili ağaç, bağlı, yönsüz ve hiçbir döngüsü olmayan sonlu bir grafiktir ve köşelerinin hepsi en fazla üç dereceye sahiptir. Çoğu bilgisayar bilimi uygulamaları için ikili ağaçlar köklüdür: En çok ikinci dereceden olan özel bir r düğümü, ağacın kökü olarak adlandırılır. Her u r düğümü için, u’dan r’ye giden yol üzerindeki ikinci düğüm, u’nun menşei olarak adlandırılır. u’ya bitişik diğer düğümlerin her biri, u’nun çocuğudur. İlgileneceğimiz ikili ağaçların çoğu sıralıdır, bu yüzden u’nun sol ve sağ çocuklarını ayrı düşünmenizde fayda vardır. Gösterimlerde, ikili ağaçlar genellikle kökten başlayarak aşağı yönde çizilir, çizimin üst kısmında kök vardır. Sol ve sağ çocuklar, sırasıyla gösterildiği gibi (Şekil 6.1), sol ve sağ dallara ayrılır. Örneğin, Şekil 6.2 dokuz düğümlü ikili ağacı gösteriyor. | 225 Önemli bir yeri olan ikili ağaç kavramında birçok yeni terminolojiye gerek duyulmuştur. Geniş kabul gören bazı tanımları listelemek gerekirse, derinlik, ata, çocuk, yükseklik, yaprak, altağaç sayılabilir. İkili ağaç içinde bir u düğümünün derinliği, u düğümü ile kök arasındaki yolun uzunluğudur. Bir u düğümünde olduğunuzu düşünelim. w ile belirtilen bir düğüm, sizinle başka bir r arasında kalıyorsa, w sizin atanız olarak hesaplanır, ve siz w ile belirtilen düğümün çocuğu sayılırsınız. Üzerinde durduğunuz düğümden bir altağaç oluşmuşsa, siz o altağacın kökü sayılırsınız. Bu altağaç sizin tüm çocuklarınızı içerir. Size ait olan bir düğümün yüksekliği, çocuğunuza giden yolun en uzun mesafesidir. Bir ağacın yüksekliği, siz kökte iken hesaplanan yüksekliktir. Hiçbir çocuğunuz yoksa, düğümünüz yapraktır. 226| Bazı durumlarda, ikili ağacın uç düğümlerini dış düğüm olarak değerlendirmek gereklidir. Sol çocuğu olmayan düğümlerin soluna bir dış düğüm, sağ çocuğu olmayan düğümlerin sağına bir dış düğüm yerleştirmek, (Şekil 6.2.b) ikili ağacın kolay doğrulanabilir özelliklerini anlamamıza yardımcı olur. Örnek vermek gerekirse, n ≥ 1 koşulunu sağlayan n gerçek düğümlü bir ikili ağacın n + 1 dış düğümü vardır. | 227 İkili Ağaç: Temel İkili Ağaç u düğümünün ikili ağaç olduğunu ifade etmenin en temel kriteri, en çok üç düğümle bağlantılı olmasıdır. Bu üç düğüm, komşu bağlantılar olarak tanımlanır: Ağaçlık koşulunun devamlılığını sağlamak niyetiyle, bu üç komşudan biri mevcut değilse, değeri nil olarak atanır. Bununla beraber, ağacın dış düğümleri ve kökün menşei de nil olacaktır. İkili ağacın kendisi köküyle ifade edilmektedir. Kök r ise: Bir u düğümünün, u’dan köke yol uzunluğu ile ölçülen derinliği, hesaplanabilir bir niceliktir: 228| Özyinelemeli Algoritmalar Özyinelemeli algoritmaları kullanarak ikili ağaç hakkında kolay hesaplanır gerçekleri ifade edebilirsiniz. Örneğin, kökü, u, olan ikili ağacın düğüm sayısını (boyutunu) hesaplamak için, özyinelemeli olarak, u düğümünde köklenmiş iki altağacın boyutları hesaplanır, sonuç bu ikisinin toplamının bir fazlası olarak döndürülür: u düğümünün yüksekliğini hesaplamak için, u’nun iki altağacının yüksekliği hesaplanır, en büyüğünün bir fazlası döndürülür: | 229 İkili Ağaçta Sıralı-Düğüm Ziyaretleri Bir önceki bölümde elde edilen algoritmaların her ikisi de, ikili ağaçtaki tüm düğümleri ziyaret etmek için özyineleme tekniğini kullanıyor. İkili ağacın düğümlerini ziyaret etme sırasını belirleyen, yazılan kodun kendisidir: Özyinelemenin ikili ağaca bu şekilde uyarlanması kodu basitleştirir, ancak sorun da yaratabilir. Özyinelemenin maksimum derinliği, ikili ağaçta bir düğümün maksimum derinliği, yani ağacın derinliği ile verilmiştir. Ağacın yüksekliği çok fazla olduğu takdirde, özyineleme kendisini fazla tekrar edeceği için Yığıt için ayrılan bellek sömürülerek kullanımı olanak dışı olur ve çöküşe sebep olabilir. Özyineleme olmadan da, ikili ağacın nereden geldiğine göre, nereye gideceğini kendisi belirleyen bir algoritma kullanabilirsiniz (bkz. Şekil 6.3). u.parent bir u düğümüne ulaşırsa, daha sonra yapılacak bir sonraki adım sol altağacı, u.left, ziyaret etmek olacaktır. Bu yönden, u düğümüne yapılacak bir ziyaret, bize sağ altağacın, u.right, yollarını açacaktır. Böylece, u düğümüne yapılacak bir ziyaret ile u altağacı tamamıyla ziyaret edilmiş olacaktır. Altağaç 230| ziyareti tamamlandıktan sonra, menşei düğüm ziyareti ile birlikte süreç sona erer. Aşağıdaki kod, sol, sağ ve menşei düğümlerin nil olmasına izin verecek şekilde, bu fikri uyguluyor: Özyinelemeli algoritmalar ile ilgili hesaplamalar özyinelemesiz kod için de geçerlidir. Örneğin, ağaç boyutunu hesaplamak için, her düğüm ziyaretinde sayaç 1 artırılarak çözüm bulunabilir: | 231 İkili ağaçların bazı uygulamalarında, menşei düğüm kullanılmaz. Bu durumda, özyinelemeli olmayan bir uygulama hala mümkündür, ancak bulunduğumuz düğümden köke giden yolda Liste (veya Yığıt) veri yapılarından herhangi birinin kullanılması, uygun ve gerekli olacaktır. 232| Yukarıdaki fonksiyonlara ait gözlemler göstermiştir ki, ziyaret sırası, desene göre değişmektedir. Bunun anlamı, önce ziyaretin deseni belirlenmelidir. | 233 Enine aramada, düğümler düzey-düzey ziyaret edilmektedir. Kökten başlar, aşağı doğru ilerler, soldan sağa doğru her seviyede düğümler ziyaret edilir (bkz. Şekil 6.4). Buna Türkçe bir metnin sayfasını okumak da diyebiliriz. Bu desen, verilen bir q, Kuyruk veri yapısı ile gerçekleştirilebilir. Başlangıçta Kuyruk’ta kök, r, bulunmaktadır. Her adımda, bir sonraki u düğümünü, q kuyruğundan ayrıştırırız, u düğümünü işleme koyarız, ve sol ve sağ düğümlerini (nil değillerse) q’a ekleriz. 234| Serbest Yükseklikli İkili Arama Ağacı Serbest Yükseklikli İkili Arama Ağacı , u.x veri değerini sıralı kri- terlere uygun olacak şekilde depolayan, özelleştirilmiş ikili arama ağaç türlerinden biridir. İkili Arama Ağacı’nda depolanan veri elemanları, Serbest Yükseklikli İkili Arama Ağacı’nın özelliklerine uyar, örneğin, büyüklük sırası soldan sağa doğru sıralanacaksa, bir u düğümü verildiğinde, 1. u.left u.x (yani, sol altağaç elimizdeki değerden küçüktür), u.x (yani, sağ altağaç elimizdeki değerden büyüktür) ve 2. u.right koşulları sağlanır. Şekil 6.5 Serbest Yükseklikli İkili Arama Ağacı’na bir örnek gösteriyor. | 235 Arama İkili Arama Ağacı veri yapısında bir değere ulaşmak oldukça ko- laydır. Kökten başlanır; herhangi bir x değeri için üç durum söz konusudur: 1. u.left araması için, x 2. u.right araması için, x u.x koşulu sağlanmalıdır. u.x koşulu sağlanmalıdır. 3. x = u.x ise, aranan düğüme ulaşılmıştır. 3.durum oluştuğunda arama başarılı, veya u=nil olduğu takdirde, başarısız sonuç döndürür. Serbest Yükseklikli İkili Arama Ağacı ’nda gerçekleştirilebilecek aramalara iki örnek Şekil 6.6’da gösterilmiştir. 236| İkinci örnekte gösterildiği gibi aramanın başarısız olduğu durumlar hakkında yargıda bulunalım: 1.durum oluştuğunda en son u düğümüne bakarsanız, u.x için büyüklük karşılaştırması yapmaya gerek duymadan, x’den büyük olan en küçük değer yargısı verebilirsiniz. Serbest Yükseklikli İkili Arama Ağacı bize bunu garanti eder. 2.durum oluştuğunda, benzer şekilde, x’den küçük olan en büyük değer yargısı verilir. Bu matematiksel yargıların yararlı özellikleri Serbest Yükseklikli İkili Arama Ağacı’nın cak arama sonucu, onlar belirgin hale gelir. içine kodlanmıştır. An- | 237 Bu bize, arama sonucunu bulmak için tasarlanan bul(x) işleminde kullanılan karşılaştırmaların, bizi x hedefine götürmede ne kadar kuvvetli bir araç olduğunu gösteriyor. 238| Ekleme Serbest Yükseklikli İkili Arama Ağacı ’na yeni bir değer eklemek için, ilk olarak x aranır. Bulunursa, eklemeye izin verilmez. Aksi takdirde, x için yapılan aramanın en sonunda ulaşılan p düğümünde, x ve p.x karşılaştırması yapılır. Büyüklük sıralaması ne gerektiriyorsa sonuca göre, elimizdeki p düğümünün sol veya sağ yaprağına, doğru bir şekilde x eklenir. Bir örnek, Şekil 6.7’de gösterilmiştir. Bu sürecin en çok zaman alan parçası, yeni eklenen, u düğümünün yüksekliğine orantılı olarak çalışan, ve x için yapılan ilk aramadır. En kötü durumda, bu Serbest Yükseklikli İkili Arama Ağacı’nın yüksekliğine eşittir. | 239 240| Silme Ağacın, u düğümünü (verisiyle birlikte) silme, İkili Arama Ağacı’nda biraz daha zordur. Silinecek u düğümü bir yaprak ise, sadece menşei’nden onu ayırmak yeterli olacaktır. Bunun için daha iyi bir yöntem vardır: u’nun sadece bir çocuğu varsa, ağaçtan u çıkarılarak, u’ya bağlı düğümler birbirine uç uça eklenir. u menşei, kendi çocuğunu evlat edinmiştir (bkz. Şekil 6.8): | 241 Silinecek düğümün ağaçta halihazırda iki çocuğu varsa, ikiden az çocuğu olan bir w düğümü için arama yapılmalıdır. Uygunluk kriteri şöyle seçilmelidir: Her durumda, Serbest Yükseklikli İkili Arama Ağacı özellikleri korunmalıdır. Silinecek düğümün değerini seçmek için büyüklük sıralamasına göre, u düğümünün sağ altağacında u.x değerinden bir sonra gelen büyüğü aranır. Her düğüm için, sağ çocuk değeri sol çocuktan büyüktür. O zaman, sağ çocuğa ait altağacın yapraklarından küçüğünü, u’nun değeri olarak atayabiliriz. Bu bize gerekli olan büyüklük sıralamasını sağlar. Böyle bir w düğümü bulunduğunda, u.x değeri w’ye aktarılır. Dikkat edilmesi gereken bir konu, u civarında w düğümlerini aramalıyız. w.x değeri u.x değerine yakın olmalıdır. Bunun için u.right altağacında 242| u.x’den büyük olan en küçük değeri buluruz. Bu düğümün çocuğu olmadığı için silmek kolaydır (bkz. Şekil 6.9). | 243 Özet Serbest Yükseklikli İkili Arama Ağacı ’nda ekle(x) gerçekleştirilen bul(x), ve sil(x) işlemleri, her ağacın kökünden bir yol izlemeyi gerektiriyor. Yol uzunluğu düğümlerin konumuna bağlıdır. Aşağıdaki teorem Serbest Yükseklikli İkili Arama Ağacı veri yapısının performansını özetlemektedir: Teorem 6.1. Serbest Yükseklikli İkili Arama Ağacı, Sıralı Küme arayüzünü uygular. İşlem başına O(n) beklenen zamanda çalışan ekle(x), sil(x) ve bul(x) işlemlerini destekler. Serbest Yükseklikli İkili Arama Ağacı yapısı ile ilgili sorun, yük- sekliğini, girdi verilerinin geliş sırasına bağlı olarak önceden belirleyememiş olmamızdır. Yani, sadece işlemler değil, ağaç yüksekliği de O(n) olabilir; işlem sayısı çok ise performans olumsuz etkile- 244| nir. Verilerin geliş sırasına bağlı olarak, eğer bir ikili ağaç zinciri oluşmuşsa (yani, son düğüm dışında her düğümün yalnız bir çocuğu varsa), Teorem 6.1 yeterli olmaz. Teorem 4.1 bir çözüm olabilir, çünkü Sıralı Küme Sekme Listesi yapısının uygulaması Sıralı Küme arayüzünün gerçekleştirimi ile O(log n) zamanda çalışır. Tüm işlemleri O(log n) çalışma zamanında gerçekleştiren Serbest Yükseklikli İkili Arama Ağacı’nı kullanmaktan kaçınmanın birkaç yolu vardır. Bölüm 7’de, O(log n) beklenen çalışma zamanlı işlemlerin rasgelelik kullanarak nasıl gerçekleştirildiğini gösteriyoruz. Bölüm 8’de O(log n) amortize çalışma zamanlı işlemlerin kısmi yeniden yapılandırma işlemlerini kullanarak nasıl gerçekleştirildiğini gösteriyoruz. Bölüm 9’da O(log n) en-kötü çalışma zamanlı işlemlerin, en fazla 4-çocuğu olan düğümlere sahip, yani ikiliolmayan bir ağaç yapısını kullanarak nasıl gerçekleştirildiğini gösteriyoruz. | 245 Tartışma ve Alıştırmalar İkili ağaçlar binlerce yıldır ilişki modellemek için kullanılmıştır. Bunun nedeni, ikili ağaçlar soy ağaçlarının doğal modeli olabilir mi sorusuydu. Aile ağacı demek daha doğrudur. Kök bir insan, sol ve sağ çocuklar ana-baba ve özyinelemeli olarak devamı sayılabilir. Daha yakın yüzyıllarda, ikili ağaçlar, biyolojide tür kavramını modellemekte kullanıldı. Ağacın yaprakları kaybolmamış türleri temsil ederken, iç düğümleri türleşmeyi temsil eder. Örnek olarak, tek bir türün iki ayrı türe dönüşmesine neden olan olayların iki ayrı popülasyonu nasıl oluşturduğu problemi verilebilir. İkili arama ağaçlarının 1950'lerde çeşitli gruplar tarafından bağımsız olarak keşfedildiği düşünülmektedir [48, Ekleme Bölümü]. İkili arama ağaçlarının koşulları değiştirilerek uygulanan tasarımları sonraki bölümlerde anlatılıyor. İkili ağacı sıfırdan uygularken birkaç tasarım noktası için karar vermek gereklidir. Bunlardan ilk soru, her düğüm menşei’ne işaretçi atanmış mıdır? Kökten başlayıp yaprağa giden yol izlerseniz, menşei işaretçilerini depolamak, zaman ve bellek kaybıdır, buna gerek yoktur. Ziyaret performansı açısından düşünürseniz, menşei kayıtlarını savunabilirsiniz. Özyinelemeli olarak veya belirli bir Yığıt yoluyla bunu gerçekleştirmek mümkündür. Diğer bazı işlem- ler için de (eş-yükseklikli ikili arama ağaçlarındaki ekleme veya silme gibi) menşei kayıtları tavsiye edilir. 246| Başka bir tasarım sorusu, her düğüm için ana-baba’yı nasıl temsil etmek gerekir? Bu bölümdeki gerçekleştirim, ayrı değişkenler yardımıyla ana-baba’yı gösterdi. Başka bir seçenek, uzunluğu 3 olan bir dizidir. Burada, p ana-baba’yı gösterir. u.p[0] sol çocuğu, u.p[1] sağ çocuğu, u.p[2] menşei gösterir. Bu gösterimle, bir dizi if kontrol cümlesini, cebirsel ifadeler halinde sadeleştirilebilirsiniz. Ağaç ziyareti sırasında, böyle bir sadeleştirmeye rastlarız. u.p[i] yönünden gelen bir ziyaretin bir sonraki adımı, (u.p[i+1] 3) mod yönünden gelir. Sağ-sol simetrisi olduğunda, benzer örnekler ortaya çıkar. u.p[i] için ağaçta kardeş görünüyorsa, bu muhakkak ki (u.p[i+1] mod 2) düğümüdür (ikili ağaç olduğu için). u.p[i], sol (i = 0) ya da sağ (i = 1) çocuk olsa da, bu ifade doğrudur. Böylece, bazı karmaşık kodların sağ ve sol versiyonlarını, solaÇevir(u), sağaÇevir(u) yöntemlerinde olduğu gibi, iki defa yeniden yazma- mız gerekli olmaz. Alıştırma 6.1. n ≥ 1 düğüme sahip ikili ağacın kenar sayısı n – 1 midir? Kanıtlayın. Alıştırma 6.2. n ≥ 1 gerçek düğüme sahip ikili ağacın dış düğüm sayısı n + 1 midir? Kanıtlayın. Alıştırma 6.3. T ikili ağacının en az bir yaprağı varsa, (a) T'nin kökü en az bir çocukludur. (b) T birden fazla yapraklıdır. Kanıtlayın. | 247 Alıştırma 6.4. u düğümünden köklü bir altağacın boyutunu hesaplayan boyut2(u) adında özyinelemeli-olmayan işlemi uygulayın. Alıştırma 6.5. İkili Arama Ağacı’ndaki bir u düğümünün yüksekliğini hesaplayan yükseklik2(u) adında özyinelemeli-olmayan işlemi uygulayın. Alıştırma 6.6. Eş-yükseklikli ikili ağacın boyutu dengelidir.(Tanım: her u düğümü için sol ve sağ altağaçların düğüm sayısı (eleman) en fazla bir adet farklılık gösterirse, ağaca boyut-dengeli denir). boyutDengeli() adında özyinelemeli bir işlemi uygulayın. Ağaç, boyut dengeli ise, true döndürmelidir. İşlem, O(n) zamanda çalışmalıdır. Düğümleri farklı konumlarda bulunan büyük ağaçlarda kodu test edin. O(n) sınırını sağlamayan ve daha çok zaman alan bir kodu yazmak, nispeten kolay olacaktır. İkili ağaçta öncül-sıra ziyareti, her u düğümünü çocuklarından önce ziyaret eder. İçsel-sıra ziyareti, her u düğümünün sol altağacını, hemen ardından sağ altağacını ziyaret ettikten sonra, u düğümünü ziyaret eder. Ardıl-sıra ziyareti, her u düğümünün altağaçlarını ziyaret ettikten sonra, u düğümünü ziyaret eder. Ağacın düğüm konumu öncül / içsel / ardıl sırada ise elemanlarının öncül / içsel / ardıl ziyarete göre sıralanması uygun olacaktır. 0,….,n – 1 için bir örnek Şekil 6.10’da verilmiştir. Alıştırma 6.7. İkili Ağaç’ın bir alt sınıfını oluşturun. Bu alt sınıfın veri alanları, öncül-sıra, ardıl-sıra, ve içsel-sıralı sayıları depola- 248| makta kullanılmalıdır. öncülSıradaSayılar(), içselSıradaSayılar() ve ardılSıradaSayılar() işlemlerini özyinelemeli olarak uygulayın. Bu işlemler, ağaçta depolanan sayıları, belirtilen sırada yazdırmalıdır. Her bir işlem O(n) zamanda çalışmalıdır. Alıştırma 6.8. Özyinelemeli sonrakiİçselSıra(u), olmayan sonrakiÖncülSıra(u), ve sonrakiArdılSıra(u) fonksiyonlarını uygu- layın. Bu işlemler, u’dan sonra gelen düğümü sırasıyla öncülsırada, içsel-sırada ve ardıl-sırada döndürmelidir. Amortize sabit zamanda çalışmalıdır. Herhangi bir u düğümünden başladığınızda, bu fonksiyonlardan birini tekrar tekrar çağırırsanız, u=null olana kadar dönüş değerini u’ya atadığınız takdirde, tüm bu çağrıların maliyeti O(n) olmalıdır. | 249 Alıştırma 6.9. Düğümlerinde öncül-, ardıl- ve içsel-sırada depolanan sayıları olan ikili ağacın verildiğini varsayın. Aşağıda belirtilen işlemlerin sabit zamanda çalışması için bu sayıları nasıl kullanabileceğinizi gösterin: 250| 1. u düğümü verildiğinde, u düğümünden başlayan altağacın bo- yutunu belirleyin. 2. u düğümü verildiğinde, u düğümünün derinliğini belirleyin. 3. u ve w düğümleri verildiğinde, u düğümü, w’nin atası mıdır? Belirleyin. Alıştırma 6.10. Öncül-sıra ve içsel-sırada depolanan düğümlerin verildiğini varsayın. Bu sıralamaya uygun en fazla bir adet ağacın var olduğunu kanıtlayın, ve ağacın nasıl düzenleneceğini gösterin. Alıştırma 6.11. n düğümü olan herhangi bir ikili ağacın en fazla 2(n – 1) bit kullanarak temsil edilebileceğini gösterin (İpucu: Ziya- ret ettiğiniz düğümleri kaydedin ve ağacı yeniden oluşturmak için kaydettiklerinizi yeniden çalıştırın). Alıştırma 6.12. Şekil 6.5’teki ikili arama ağacına 3,5 ve 4,5 değerlerini eklediğinizde neler olacağını gösterin. Alıştırma 6.13. Şekil 6.5’teki ikili arama ağacından 3 ve 4 değerlerini sildiğinizde neler olacağını gösterin. Alıştırma 6.14. küçükEşitListesi(x) İkili Arama Ağacı veri yapısına ait işlemini uygulayın. Bu işlem, x elemanından küçük ya da eşit düğümlerin listesini döndürür. x elemanından küçük ya da eşit eleman sayısı n’ ile belirtildiğinde, ve h ağacın yüksekliğiyse, işlem O(n’ + h) zamanda çalışmalıdır. | 251 Alıştırma 6.15. Başlangıçta boş olan İkili Arama Ağacı’na {1,…,n} elemanları kaç değişik şekilde eklenebilir ki, ağacın yüksekliği n – 1 olsun? Alıştırma 6.16. İkili Arama Ağacı üzerinde, önce ekle(x), hemen ardından sil(x) gerçekleştirirseniz (x aynı değeri taşıyor), arama ağacındaki düğümlerin konumları değişir mi? Orijinal ağaca, zorunlu olarak, geri döner miyiz? Alıştırma 6.17. İkili Arama Ağacı’nda sil(x) işlemi, herhangi bir düğümün yüksekliğini arttırabilir mi? Artırırsa, ne kadar artırır? Alıştırma 6.18. İkili Arama Ağacı’nda ekle(x) işlemi, herhangi bir düğümün yüksekliğini arttırabilir mi? Ağacın yüksekliğini artırabilir mi? Artırırsa, ne kadar artırır? Alıştırma 6.19. İkili Arama Ağacı’nın bir versiyonunu tasarlayın ve uygulayın. Her u düğümü, u.boyut (u düğümünden başlayan altağacın boyutu), u.derinlik (u düğümünün derinliği), ve u.yükseklik (u ekle(x) düğümünün yüksekliği) veri alanlarını saklamalıdır. ve sil(x) işlemlerine yapılan çağrıların maliyeti sabit oran- dan daha fazla artmamak kaydıyla, bu değişkenler veri yapısına dahil edilmelidir. 252| | 253 Bölüm 7 Rasgele İkili Arama Ağaçları Bu bölümde, rasgelelik kullanarak, tüm işlemler için O(log n) beklenen çalışma zamanını gerçekleştiren Rasgele İkili Arama Ağacı veri yapısını tanıtacağız. Rasgele İkili Arama Ağaçları Şekil 7.1’de verilen, her biri n = 15 düğümlü iki adet ikili arama ağacını göz önünde bulundurun. Soldaki bir listedir, ve sağdaki tamamen dengeli ikili arama ağacıdır. Soldaki ağaç, n – 1 = 14 yüksekliğe sahiptir, sağdaki ağacın yüksekliği ise 3’tür. Bu iki ağacın nasıl oluşturulduğunu düşünelim. Boş bir yapı ile başlandığında, ve aşağıdaki veri dizisini İkili Arama Ağacı’na sırasıyla ekleyerek soldaki ağaç elde edilmiştir. Başka bir sırayla gerçekleştirilen hiçbir ekleme, bu ağacı oluşturamaz (n üzerinde tümevarım yöntemiyle kanıtlayabilirsiniz). Diğer 254| taraftan, sağdaki ağaç, aşağıdaki veri dizisinin eklenmesiyle oluşturulabilir: Aşağıdaki diğer diziler de bu ağacı oluşturmak için kullanılabilir: ve İşin gerçeği, sağdaki ağacı oluşturan 21.964.800 ekleme dizisi varken, sadece bir adet dizi soldaki ağacı oluşturur. Yukarıdaki örnekten bazı bulguları çıkarabiliriz: 0…14 aralığındaki sayıların rasgele permütasyonunu seçtiğimizde, ve bu sayıları ikili arama ağacına eklediğimizde, çok dengeli bir ağacı (Şekil 7.1’in sağ tarafı) elde etme olasılığımız, çok dengesiz bir ağacı (Şekil 7.1’in sol tarafı) elde etme olasılığımızdan daha fazladır. | 255 Bu kavramı rasgele ikili arama ağaçlarını inceleyerek şekillendirebiliriz: n boyutunda bir rasgele ikili arama ağacı şöyle elde edilir: 0,…,n – 1 arasında rasgele x0,…,xn-1 permütasyonu seçin ve ele- manlarını teker teker İkili Arama Ağacı’na ekleyin. Rasgele permütasyon şu anlamdadır: 0,…,n – 1 sayılarının mümkün olan her bir n! permütasyonu (sıralaması) eşit derecede olasıdır, yani herhangi bir permütasyonu elde etme olasılığı 1/n! olur. Unutmayın ki, 0,…,n – 1 değerleri, Rasgele İkili Arama Ağacı’nın özelliklerinden herhangi birini değiştirmeden, herhangi bir sıralı n eleman dizisi ile yer değiştirebilir. x {0,…,n – 1} elemanı, n boyutunda sıralı bir küme içinde, x’nci sıradaki elemana vekalet ediyor. Rasgele İkili Arama Ağaç’ları ile ilgili başlıca sonucumuzu tanıt- madan önce, konudan biraz uzaklaşarak, randomize yapılar incele- 256| nirken sık sık gündeme gelen bir sayı türünü gündeme getireceğiz. Negatif olmayan bir k tamsayısı için, Hk ile gösterilen k’nci harmonik sayı, olarak tanımlanır. Harmonik sayı Hk için hiçbir basit, kapalı yapı yoktur, ama çok yakından k’nın doğal logaritması ile ilgilidir. Özellikle, yazılabilir. Fark edebileceğiniz gibi, olması nede- niyle bu böyledir. İntegrali bir eğri ve x-ekseni arasında kalan alan olarak yorumlayabileceğinizi akılda tutarak, integrali tarafından alttan-sınırlı, ve Hk değerinin tara- | 257 fından üstten-sınırlı olduğunu kaydedebilirsiniz. (Grafiksel açıklama için, bkz. Şekil 7.2). Önerme 7.1. n boyutunda Rasgele İkili Arama Ağacı’nda, aşağıdaki ifadeler doğrudur: 1. Herhangi bir x {0,…,n – 1} uzunluğu 2. Herhangi bir x için, arama yolunun beklenen olur. (–1, n) \ {0,…,n – 1} beklenen uzunluğu için, arama yolunun olur. Önerme 7.1’i sonraki bölümde kanıtlayacağız. Şimdilik ilgilenmemiz gereken konu, Önerme 7.1’in iki bölümü ne anlatıyor? Birinci bölüm, n boyutunda bir ağaçta bulunan bir eleman için arama yaparsanız, arama yolunun en fazla 2ln n + O(1) beklenen uzunlukta olduğunu bize anlatır. İkinci bölüm ağaçta depolanmayan bir değer için yapılan arama hakkında aynı sonucu anlatır. Önermenin bu iki bölümünü karşılaştırdığımızda, ağaçta yer alan bir elemanı aramanın, ağaçta bulunmayan bir elemanı aramaktan sadece biraz daha hızlı olduğunu söyleyebiliriz. 258| Önerme 7.1’in Kanıtı Önerme 7.1’i kanıtlayacak anahtar gözlem şudur: T’yi oluşturmak için kullanılan rasgele permütasyonda, i, ancak ve ancak elemanlarından önce geliyorsa, i x anahtarlı bir düğüm, (–1, n) açık aralığındaki x’in arama yolu üzerinde bulunur. Bunu görmek için Şekil 7.3’ten fark etmelisiniz ki, elemanlarından biri eklenene kadar, açık aralığındaki her değer için arama yolları özdeştir (Unutmayın ki, iki değerin farklı arama yolları olması için, ağaçta, onlarla karşılaştırma değerleri farklı olan bazı elemanların bulunması gerekir). içinde rasgele permütasyonda görünür ilk eleman j olsun. | 259 Dikkat edin, x’in her arama yolunda, j, yol üzerinde bulunmak, yani görünmek zorundadır. Elemanların farklı olduğu durumda, yani j i ise, j elemanını içeren uj düğümü, i elemanını içeren ui düğümünden önce oluşturulmuştur, demek kesin olarak doğrudur, çünkü i j (soldan sağa doğru yer alırlar). Bu nedenle, şu da kesin olarak doğrudur ki, ağaca i elemanı eklendiğinde, uj.left kökenli altağaca eklenir. Diğer taraftan, x için arama yolu bu altağacı hiçbir zaman ziyaret etmeyecektir, çünkü uj düğümünü ziyaret ettikten sonra uj.right altağacına doğru ziyarete devam edecektir. Benzer şekilde, i x için, T’yi oluşturmak için kullanılan rasgele permütasyonda i, ancak ve ancak elemanla- rından önce geliyorsa, i düğümü, x’in arama yolu içinde yer alır. Fark etmelisiniz ki, {0,…,n} rasgele permütasyonu ile başladığınızda, ve altdizileri de sırasıy- la kendi elemanlarının rasgele permütasyonlarıdır. O zaman, ve eşit olasılıkla, altkümelerinin her elemanı, T’yi oluşturmak için kullanılan rasgele permütasyondaki herhangi bir elemandan önce görünecektir. Bu nedenle, Bu gözlem ile, Önerme 7.1’in kanıtı, harmonik sayılar ile yapılan bazı basit hesaplamaları gerektirmektedir: 260| Önerme 7.1’in Kanıtı. i, x’in arama yolunda bulunuyorsa Ii gösterge rasgele değişkeninin değeri 1, aksi takdirde 0 olsun. O zaman arama yolunun uzunluğunu, olarak yazabiliriz. Bu nedenle, x {0,…,n – 1} luğu (bkz. Şekil 7.4.a), için arama yolunun beklenen uzun- | 261 olarak hesaplanır. x (–1, n) \ {0, …, n – 1} arama değerleri için ilgili hesaplama- lar hemen hemen aynıdır (bkz. Şekil 7.4.b). 262| Özet Aşağıdaki teorem Rasgele İkili Arama Ağacı’nın performansını özetlemektedir: Teorem 7.1: Rasgele İkili Arama Ağacı, O(n logn) zamanda oluşturulabilir. Rasgele İkili Arama Ağacı’nda, bul(x) işlemi, O(log n) beklenen zamanda çalışır. Tekrar vurgulamalıyız ki, Teorem 7.1’deki beklenen zaman, Rasgele İkili Arama Ağacı’nı oluşturmak için kullanılan rasgele permütasyona bağlıdır. Özellikle, rasgele x seçimlerine bağlı değildir; ve her x değeri için bu doğrudur. | 263 Treap: Rasgele İkili Arama Ağaçları Rasgele İkili Arama Ağaç’ları ile ilgili sorun, tabii ki, dinamik ol- mamalarıdır. Sıralı Küme arayüzünü uygulamak için gerekli ekle(x) veya sil(x) işlemlerini desteklemezler. Bu bölümde, Sıralı Küme arayüzünü uygulamak için Önerme 7.1’i kullanan, Treap adında bir veri yapısını tanımlıyoruz. Treap düğümü, İkili Arama Ağacı düğümüne benzer şekilde, bir x veri değerine ve aynı zamanda p adı verilen, rasgele ve tekil olarak atanan bir sayısal öncelik değerine sahiptir: 264| İkili Arama Ağacı olmasının yanı sıra, Treap düğümleri Yığın özel- liklerini de sağlar: (Yığın Özelliği) Kök hariç, her u düğümünde, u.parent.p u.p Diğer bir deyişle, her düğüm iki çocuğundan daha az önceliğe sahiptir. Şekil 7.5’te bir örnek gösterilmiştir. Her düğüm için key(x) ve priority(p) tanımlanmasıyla birlikte, Yığın ve İkili Arama Ağacı koşulları Treap şeklini tam olarak belir- ler. Yığın özelliği, minimum öncelikli, r düğümünün kök olması gerektiğini sağlar. İkili Arama Ağacı özelliği r.x’den küçük anahtara sahip tüm düğümlerin r.left kökenli altağaçta depolanmasını, ve r.x’den büyük anahtara sahip tüm düğümlerin r.right kökenli altağaçta depolanmasını sağlar. Treap’te öncelik değerleri hakkında önemli olan bir nokta, onların tekil ve rasgele atanmalarıdır. Bu nedenle, Treap düşüncesi için iki eşdeğer yol vardır: Yukarıda tanımlandığı gibi Treap, Yığın ve İkili Arama Ağacı özelliklerini sağlar. Alternatif olarak, Treap düğümle- rini artan öncelik sırasıyla eklenen bir İkili Arama Ağacı olarak düşünebilirsiniz. Örneğin, Şekil 7.5’te Treap, (x, p) sıralı ikili değerlerinin İkili Arama Ağacı’na eklenmesiyle oluşturulabilir. | 265 Öncelikler rasgele seçilmiş olduğu için bu, anahtarların rasgele permütasyonunu almakla eşdeğerdir – bu durumda permütasyon, olur, ve İkili Arama Ağacı’na bu elemanlar eklenir. Böylece oluşturulan Treap şekli, Rasgele İkili Arama Ağacı ile aynıdır. Özellikle, her x anahtarını, permütasyon sırası ile yer değiştirirsek, Önerme 7.1 geçerlidir. Önerme 7.1 Treap bakımından yeniden düzenlenerek şu hale gelir: Önerme 7.2. n anahtardan oluşan S eleman dizisini depolayan bir Treap için, aşağıdaki açıklamalar geçerlidir: 1. Her x S için, x için arama yolunun beklenen uzunluğu, olur. 2. Her x S için, x için arama yolunun beklenen uzunluğu, olur. r(x) burada, S {x} içinde x’in sırasını göstermektedir. Yine vurgulamalıyız ki, Önerme 7.2’deki beklenen uzunluk, her düğüm için rasgele öncelik seçimleri üzerinden alınmıştır. Anahtarların rasgeleliği hakkında herhangi bir varsayım gerekli değildir. Önerme 7.2, Treaps veri yapısının bul(x) işlemini verimli olarak uygulayabileceğini anlatıyor. Ancak, Treap veri yapısının gerçek 266| yararı, ekle(x) ve sil(x) işlemlerini destekleyebilmesidir. Bunu yapmak için, Yığın özelliğini korumak için birkaç döndürüş gerçekleştirmeye ihtiyaç vardır (bkz. Şekil 7.6). İkili Arama Ağacı’nda döndürüş, İkili Arama Ağacı özelliğini koruyarak, w düğümünün menşei olan u üzerinde yapılan yerel bir değişikliktir. Döndürüşle, w düğümünün menşei olan u alınır, ve u menşei olarak w düğümü belirlenir. İki çeşit döndürüş vardır: w düğümünün sol veya sağ çocuk olmasına bağlı olarak sırasıyla, sola döndürüş ve sağa döndürüş. Döndürüşü gerçekleştiren kod, bu iki olasılığı işlemek zorundadır ve (u kök olduğunda) sınır değerlere dikkat edilmelidir, böylece ortaya çıkan gerçek kodun uzunluğu Şekil 7.6’da gösterildiğinden daha uzundur. | 267 268| Treap veri yapısı açısından, bir döndürüşün en önemli özelliği, w derinliğinin 1 azalması ve u derinliğinin 1 artmasıdır. Döndürüşleri kullanarak, ekle(x) işlemini aşağıdaki gibi gerçekleştirebilirsiniz: Yeni bir u düğümü oluştururuz, u.x = x olarak belirleriz, ve u.p için rasgele değer atarız. Bundan sonra, İkili Arama Ağacı için olağan ekle(x) algoritmasını kullanarak, x elemanını ekleriz. u şimdi Treap veri yapısının yaprağı olmuştur. Bu noktada Treap, İkili Arama Ağacı’nın Yığın özelliğini yerine getirmektedir, ancak özelliğini sağlaması hakkında kesin bir şey söyleyemeyiz. Özellikle, u.parent.p > p durumu söz konusu olabilir. Bu durumda ise, w=u.parent iken, w’nin menşei u olacak şekilde bir döndürüş gerçekleştirilir. u, Yığın özelliğine aykırı olmaya devam ederse, her tekrarlamada u derinliği 1 azaltılarak, u kök olana kadar veya u.parent.p ekle(x) u.p olana kadar döndürüş tekrarlanır. işleminin bir örneği, Şekil 7.7’de gösterilmiştir. | 269 ekle(x) işleminin çalışma zamanı, x için yapılan arama yolunun izlenmesi için gereken süre, ve yeni eklenen u düğümünün, Treap içinde, olması gerektiği doğru yere kadar taşınması için gerçekleştirilen döndürüş sayısına bağlıdır. Önerme 7.2 ile, arama yolunun beklenen uzunluğu en fazla 2ln n + O(1) olarak belirlenmiştir. Ayrıca, her bir döndürüşün, u derinliğini azalttığı biliniyor. u kök olduğunda döndürüş sona ermelidir, bu nedenle beklenen döndürüş sayısı, gerçekleştirilen arama yolunun beklenen uzunluğundan fazla olmamalıdır. Bu nedenle, Treap tarafından gerçekleştirilen ekle(x) işleminin beklenen çalışma zamanı O(log n) olarak kaydedilir (Alıştırma 7.5 bir ekleme sırasında gerçekleştirilen beklenen döndürüş sayısının O(1) olduğunu göstermenizi istiyor). 270| Treap içinde sil(x) işlemi ekle(x) işleminin zıttıdır. x içeren u dü- ğümünü ararız, sonra u bir yaprak haline gelinceye kadar, u düğümünü aşağı yönde hareket ettirecek döndürüşleri gerçekleştiririz. Treap yapısından u çıkarılarak, u’ya bağlı düğümleri birbirine uç uça ekleriz. Fark edebilirsiniz ki, u düğümünü aşağı yönde hareket ettirmek için u düğümünü, sırasıyla, u.left veya u.right ile yer değiştiren, sola veya sağa döndürüşü yerine getirebilirsiniz. Aşağıdakilerden hangisi önce geçerliyse, seçim onun tarafından yapılır: 1. u.left ve u.right, her ikisi de null ise, o zaman u bir yapraktır ve hiçbir döndürüş uygulamayın. 2. u.left (veya u.right) null ise, u düğümünden sağa doğru (veya sırasıyla, sola doğru) döndürüş uygulayın. 3. u.left.p u.right.p (veya u.left.p u.right.p) ise, sağa doğru (veya sırasıyla, sola doğru) döndürüş uygulayın. Bu üç kural, Treap yapısının bağlantılarını koparmadan, u düğümü silindiğinde de, Yığın özelliğinin korunmasını sağlar. sil(x) işleminin bir örneği, Şekil 7.8’de gösterilmiştir. sil(x) işleminin çalışma zamanını analiz etmek için gerekli olan beceri, bu işlemi ekle(x) işleminin zıttı olarak fark edebilmektir. Özellikle, aynı öncelikteki u.p kullanarak x değerini yeniden eklemek isteseydik, ekle(x) işlemi aynı sayıda tam döndürüş yapardı, ve Treap özelliklerini, sil(x) işleminin gerçekleşmesinden önceki duruma getirerek yeniden korurdu. | 271 (Aşağıdan-yukarıya doğru okunduğunda, Treap içine 9 değerinin eklenmesi, Şekil 7.8’de gösterilmiştir). n boyutundaki Treap için sil(x) işleminin beklenen çalışma zamanı, n – 1 boyutundaki Treap için ekle(x) işleminin beklenen çalışma zamanı ile orantılıdır. Sonuç olarak, sil(x) işlemi O(log n) beklenen zamanda çalışır. 272| Özet Aşağıdaki teorem Treap veri yapısının performansını özetlemektedir: Teorem 7.1: Treap, Sıralı Küme arayüzünü uygular. Treap, işlem başına O(log n) beklenen zamanda çalışan ekle(x), sil(x) ve bul(x) işlemlerini destekler. Treap veri yapısını Sıralı Küme Sekme Listesi ile karşılaştırmak dikkate değerdir. Her ikisi de O(log n) zamanda çalışan işlemleri destekliyor. Her iki veri yapısı da, ekle(x) ve sil(x) işlemleri sırasında yapılan arama sonrasında, sabit sayıda işaretçi değişikliklerini gerçekleştirir (bkz. Alıştırma 7.5). Bu nedenle, her iki yapı için, performans üzerine etki eden en kritik değer, arama yolunun beklenen uzunluğudur. Sıralı Küme Sekme Listesi’nde arama yolunun beklenen uzunluğu, ile verilmişti. Treap için bu sayı, olarak verilir. | 273 Bu durumda, Treap arama yolları Sekme Liste’lerine göre daha kısadır ve bununla beraber, farkedilir derecede daha yüksek hızlı işlemleri Treap veri yapısı üzerinde uygulayabilirsiniz. Bölüm 4’te verilen Alıştırma 4.7, Sekme Listesi’nde arama yolunun beklenen uzunluğunu, hileli para fırlatarak nasıl, sayısına azaltabileceğimizi gösteriyor. Bu iyileştirme ile bile olsa, Sıralı Küme Sekme Listesi’nin Treap beklenen arama uzunluğu yolu ile karşılaştırıldığında daha uzundur. 274| | 275 276| Tartışma ve Alıştırmalar Rasgele ikili arama ağaçlar yaygın olarak kullanılmaktadır. Önerme 7.1’in kanıtı ve ilgili sonuçları Devroye [19] tarafından verilmiştir. Literatürde daha kuvvetli sonuçlar da bulunmaktadır, başlıcası Reed [64] tarafından, Rasgele İkili Arama Ağacı’nın beklenen yüksekliğinin olduğunu göstermiştir. Burada, aralığındaki tekil çözümü 4,31107, ve denkleminin ve- rilmiştir. Ayrıca, yüksekliğin değişkenliği sabittir. Treap adı Seidel ve Aragon [67] tarafından bilime kazandırılırken, bazı varyasyonları da tartışılmıştır. Ancak, temel yapısı Vuillemin [76] tarafından çok daha önceden Kartezyen Ağaçlar adıyla çalışılmıştır. Treap p veri yapısı için olası bir alan-optimizasyonu, her düğümdeki öncelik alanının açıkça saklanmasından vazgeçmektir. Bunun yerine, bir, u düğümünün önceliği, u adresinin bellekteki karma değeri olarak hesaplanır (32-bit Java’da, u.hashCode() fonksiyonuyla karma yapılabilir). Pek çok karma fonksiyonu bu uygulama için muhtemelen iyi çalışsa da, Önerme 7.1’in kanıtını oluşturan önemli parçaların geçerliliğini yitirmemesi için karma fonksiyonu randomize edilmelidir, ve asgari bağımsızlık özelliğine sahip olma- | 277 lıdır: Birbirinden h(x1),…,h(xk) ayrı, herhangi x1,…,xk değerleri için karma değerlerinin her biri yüksek olasılıkla birbi- rinden farklı olmalıdır, ve her i {1,…,k} için, eşitsizliğini sağlayan bir c sabiti vardır. Bu tür karma fonksiyonları arasında, uygulaması kolay ve oldukça hızlı olan bir tanesi listeleme karmadır (bkz. Listeleme Karma Yöntemi Bölümü). Her düğüm noktasında öncelikleri depolamaya gerek duymayan bir başka Treap varyasyonu, Martinez ve Roura [51] tarafından bilime kazandırılan randomize ikili arama ağacıdır. Bu varyasyonda, her u düğümünde, u kökenli altağacın boyutu u.boyut ile tanımlıdır. ekle(x) ve sil(x) algoritmalarının ikisi de rasgeledir. u kökenli alt ağaca, x elemanının eklenmesi aşağıdakileri yapar: 1. 1/(boyut(u)+1) olasılığıyla, x değeri her zamanki gibi yaprak olarak eklenir, ve x bu ağacın köküne getirilene kadar döndürüş gerçekleşir. 2. Aksi takdirde, 1 – 1/(boyut(u)+1) olasılığıyla, x değeri özyinelemeli olarak u.left veya u.right kökenli ağaçlardan uygun olanına eklenir. Birinci durum, Treap içindeki ekle(x) işlemine karşılık geliyor. Burada, x’in düğümü rasgele bir öncelik değeri alır ve bu değer, u 278| altağacındaki boyut(u) önceliklerinin hepsinden daha küçüktür. Bu durum tam olarak aynı olasılıkla oluşur. Randomize Treap’teki u İkili Arama Ağacı’ndan bir x değerini silmek, silme sürecine benzerdir. x içeren u düğümü bulunur, ve bir yaprak haline gelene kadar u derinliğini artıran ard arda dön- dürüşler gerçekleşir. Bu noktada, u ağaçtan çıkarılabilir. Her adımda gerçekleştirilen döndürüşün sola mı, veya sağa mı olması seçimi randomize edilmiştir. 1. u.left.boyut/(u.boyut – 1) olasılığıyla, u kökenli altağacın kökü u.left olacak şekilde sağa döndürüş gerçekleştiririz. 2. u.right.boyut/(u.boyut – 1) olasılığıyla, u kökenli altağacın kökü u.right olacak şekilde sola döndürüş gerçekleştiririz. Bu olasılıkların Treap içindeki silme algoritmasının gerçekleştireceği sola veya sağa döndürüşler ile aynı olduğunu kolayca doğrulayabilirsiniz. Treap veri yapısı ile karşılaştırıldığında, eleman ekleme ve silme yaparken, Randomize İkili Arama Ağaç’ların birçok rasgele seçimler yapması dezavantajdır ve altağaçların boyutları korunmak zorundadır. Randomize İkili Arama Ağaç’ların Treap veri yapısına kıyasla bir avantajı, altağaç boyutunun bir başka yararlı amaca hizmet edebilmesidir; O(log n) beklenen zamanda sırasına göre eleman erişimi (bkz. Alıştırma 7.10) sağlar. Treap düğümlerinde | 279 depolanan rasgele önceliklerin ise, Treap yapısını dengeli halde tutmak dışında bir kullanım amacı yoktur. Alıştırma 7.1. Şekil 7.5’te verilen Treap içine (önceliği 7 olan) 4,5 değerinin, ve daha sonra (önceliği 20 olan) 7,5 değerinin eklenmesini gösterin. Alıştırma 7.2. Şekil 7.5’te verilen Treap içinden 5 ve 7 değerlerinin silinmesini gösterin. Alıştırma 7.3. Şekil 7.1’in sağ tarafında bulunan ağacın 21.964.800 dizi tarafından oluşturulabileceğini kanıtlayın (İpucu: h yüksekliğine sahip ikili ağacı oluşturacak dizilerin sayısını bir özyinelemeli formülle ifade edin. h = 3 için formülün değerini hesaplayın). Alıştırma 7.4. n farklı değerin sırasını rasgele değiştirilmiş şekilde saklayan a dizisini girdi olarak alan, sırasınıDeğiştir(a) işlemini tasarlayın ve uygulayın. İşlem, O(n) zamanda çalışmalıdır, ve a dizisinin her n! permütasyonunun eşit olasılıkla mümkün olabileceğini kanıtlamalısınız. Alıştırma 7.5. Önerme 7.2’nin her iki bölümünü de kullanarak ekle(x) ve sil(x) işlemiyle gerçekleştirilen döndürüşlerin beklenen sayısının O(1) olduğunu kanıtlayın. Alıştırma 7.6. Bu bölümde verilen Treap uygulamasını, öncelikleri açıkça depolamayacak şekilde değiştirin. Bunun yerine, her düğüm, 280| hashCode() ile karma fonksiyonunu kullanarak öncelik gibi gös- termelidir. Alıştırma 7.7. İkili Arama Ağacı içindeki her u düğümünde, u kökenli altağacın yüksekliği u.yükseklik, ve u kökenli altağacın büyüklüğü, u.boyut değişkenlerinin depolandığını düşünün. 1. u düğümünde, sola ve sağa döndürüş gerçekleştiğinde, döndürüşten etkilenen tüm düğümler için bu iki değişkenin, sabit sürede nasıl güncellenebileceğini gösterin. 2. Her u düğümü için, u derinliğini de depolamaya çalıştığınız takdirde, aynı sonucun neden geçerli olmadığını açıklayın. Alıştırma 7.8. n elemandan oluşan sıralı a dizisinin elemanlarını ekleyerek, Treap oluşturan bir algoritmayı tasarlayın ve uygulayın. Bu işlem, en kötü O(n) zamanında çalışmalıdır ve a elemanlarını ekle(x) Treap işlemiyle teker teker çağırarak eklediğiniz takdirde, aynı yapısını elde ediyor olmanız gerekir. Alıştırma 7.9. Bu alıştırma, Treap içinde aradığınız düğüme yakın bir işaretçi verildiğinde, nasıl verimli arama yapabileceğinizin detaylarını veriyor. 1. Her düğümün, kendi altağacında bulunan en küçük ve en büyük değerlerin bilgisini tuttuğu bir Treap uygulamasını tasarlayın ve uygulayın. | 281 2. Bu ekstra bilgiyi kullanarak, parmakBul(x, u) işlemini uygulayın. Bu işlem u düğümünü gösteren bir işaretçinin yardımıyla bul(x) işlemini çalıştırır (işaretçinin x değerini içeren düğüm- den fazla uzak mesafede olmaması tercih edilir). Bu işlem u düğümünden başlar ve w.min x w.max koşulunu sağla- yan bir w düğümüne ulaşıncaya kadar yukarı yürür. Bu noktadan itibaren, x için w düğümünden başlayarak standart bir arama yapar (Treap içinde bulunan elemanların sayısı r ile ifade edildiğinde, r değeri x ve u.x arasında iken, parmakBul(x, u) işleminin O(1 + log r) zamanda çalıştığını gösterebilirsiniz). 3. bul(x) işlemine yapılan her çağrının, bul(x) işleminin en son çağrısında döndürülen düğümden başlayarak aramayı gerçekleştirmesi için, Treap uygulamasında değişiklikler yapın. Alıştırma 7.10. Treap içinde i’nci sıradaki anahtarı döndüren al(i) işlemini gerçekleştiren Treap versiyonunu tasarlayın ve uygulayın (İpucu: Her u düğümü, u kökenli altağacın boyutu bilgisini saklar). Alıştırma 7.11. Liste arayüzünün bir Treap şeklinde gerçekleştirildiği, TreapList adındaki veri yapısını uygulayın. Treap içindeki her düğüm bir Liste elemanını depolar. Treap için yapılan içselsıralamada ziyaret edilen elemanlar aynı sırada, Liste’de göründüğü sırada görünür. Tüm Liste işlemleri, al(i), belirle(i, x), ekle(i, x) ve sil(i), O(n) beklenen zamanda çalışmalıdır. Alıştırma 7.12. böl(x) işlemini destekleyen bir Treap versiyonunu tasarlayın ve uygulayın. Bu işlem, Treap içinde depolanmış, x’den 282| daha büyük olan tüm değerleri siler ve tüm silinen değerleri içeren ikinci bir Treap döndürür. Örnek: t2 = t.böl(x) kodu, t içinden x’den daha büyük tüm değerleri ayırır, ve yeni Treap t2 olarak döndürür. böl(x) işlemi, O(log n) beklenen zamanda çalışmalıdır. Uyarı: Bu değişikliğin doğru olması, ve boyut() işleminin sabit zamanda çalışması için Alıştırma 7.10’da belirtilen değişiklikleri uygulamanız gerekmektedir. Alıştırma 7.13. böl(x) işleminin tersi olarak düşünebileceğiniz, em(t2) işlemini destekleyen bir Treap versiyonunu tasarlayın ve uygulayın. Bu işlem, Treap, t2 içindeki tüm değerleri siler, ve alıcıya ekler. Bu işlem, t2 içindeki en küçük değerin, alıcı içindeki en büyük değerden daha büyük olduğunu önceden varsayar. em(t2) işlemi O(log n) beklenen zamanda çalışmalıdır. Alıştırma 7.14. Bu bölümde anlatıldığı üzere, Martinez'in Randomize İkili Arama Ağaç’larını uygulayın. Treap uygulaması- nın performansı ile sizin yazdığınız uygulamanın performansını karşılaştırın. | 283 284| Bölüm 8 Günah Keçisi Ağaçları Bu bölümde, İkili Arama Ağacı veri yapısı olan, Günah Keçisi Ağacı’nı inceleyeceğiz. Bu yapı, bir şeyler yanlış gittiğinde, insanların birilerini suçlamak (günah keçisi) eğiliminde olması gibi bir ortak akla dayanır. Suçlama sıkıca saptandıktan sonra, sorunu çözmek için günah keçisini terk edebilirsiniz. Günah Keçisi Ağacı, kısmi yeniden yapılandırma işlemleriyle ken- dini dengeli tutar. Kısmi yeniden yapılandırma işlemi sırasında, bütün bir altağaç sökülerek parçalarına ayrıştırılır, ve mükemmel dengeli bir altağaç için yeni baştan kurulur. u-düğümünde köklü bir altağacı mükemmel dengeli bir ağaç halinde yeniden yapılandırmanın birçok yolu vardır. En basit bir tanesi, u’nun altağacını ziyaret ederek, bütün düğümlerini bir a dizisinde toplamak, ve sonra a dizisini kullanarak, özyinelemeli olarak dengeli bir altağacı oluşturmaktır. m = a.uzunluk/2 olmasına izin verirsek, a[m] yeni altağacın kökü haline gelir, a[0],…,a[m–1] sol altağaçta öz yinelemeli olarak depolanır, a[m+1],…,a[a.uzunluk–1] sağ altağaçta özyinelemeli olarak depolanır. | 285 yeniden_oluştur(u) için yapılan bir çağrı O(boyut(u)) zamanda çalışır. Elde edilen altağaç minimum yüksekliğe sahiptir; boyut(u) düğüm sayısına sahip olan, daha az yükseklikte hiçbir ağaç yoktur. 286| Günah Keçisi Ağacı: Kısmi Yeniden Oluşturmalı İkili Arama Ağacı Günah Keçisi Ağacı, n düğüm sayısına ek olarak, n’e üst-sınırı sağ- layan q sayacını tutan bir İkili Arama Ağacı’dır. Her zaman için, n ve q, aşağıdaki eşitsizliği sağlar: | 287 Buna ek olarak, Günah Keçisi Ağacı logaritmik yüksekliğe sahiptir; günah keçisi ağacının yüksekliği hiçbir zaman aşağıdaki değeri geçmez: Hatta bu sınırlamayla bile, Günah Keçisi Ağacı şaşırtıcı biçimde dengesiz görünebilir. Şekil 8.1’deki ağaçta, q = n = 10, ve yükseklik olarak belirlidir. İkili Arama Ağacı’nın standart arama algoritmasını kullanarak, Gü- nah Keçisi Ağacı’nda bul(x) işlemini gerçekleştirebiliriz (bkz. Ser- best Yükseklikli İkili Arama Ağacı Bölümü). Bu işlemin çalışma zamanı, ağacın yüksekliği ile orantılı olduğu için (8.1) nedeniyle, O(log n) zaman alır. ekle(x) işlemini gerçekleştirmek için, önce n ve q değişkenlerini 1 artırırız, daha sonra İkili Arama Ağacı’na x değerini eklemek için her zamanki algoritmayı kullanırız; önce x için arama yaparız, ve u.x = x olan yeni bir u yaprağını ağaca ekleriz. Bu noktada şanslı olabiliriz, ve u derinliği log3/2 q sayısını aşmayabilir. Eğer öyleyse, Günah Keçisi Ağacı’nı artık yalnız bırakırız ve hiçbir şey yapma- yız. Ne yazık ki, bazen derinlik(u) log3/2 q olabilir. Bu durumda, yüksekliğin azaltılması gereklidir. Bu iş çok fazla zahmet gerektirmez, derinliği log3/2 q sayısını aşan sadece bir adet u düğümü var- 288| dır. u’yu düzeltmek için, u’dan başlayıp köke doğru günah keçisi w’yi arayarak yukarı yürürüz. Günah keçisi w, çok dengesiz bir düğümdür. Şu özelliğe sahiptir: Burada, w.child, kökten u düğümüne giden yolda, w düğümünün çocuğudur. Günah keçisinin var olduğunu çok kısaca kanıtlayacağız. Şimdilik, buna kesin gözüyle bakabiliriz. Bir kez, günah keçisi w’yi bulduğumuz zaman, w köklü altağacı tamamen yok ederiz ve mükemmel dengeli bir ikili arama ağacı halinde yeniden yapılandırırız. (8.2) gösteriyor ki, u eklenmeden önce bile, w altağacı tam İkili Ağaç değildi. Bu nedenle, w yeniden yapılandırıldığında, yük- seklik en az 1 azalır, böylece Günah Keçisi Ağacı’nın yüksekliği yeniden en fazla log3/2 q olur. | 289 Günah Keçisi w’yi bulmanın ve w kökenli altağacı yeniden oluşturmanın maliyeti önemsenmediği takdirde, ekle(x) işleminin çalışma zamanı, O(log q) = O(log n) karmaşıklığında yapılan ilk arama tarafından büyük oranda etkilenir. Günah Keçisi’ni bulmanın ve yeniden yapılandırmanın maliyetini, amortize analiz kullanarak sonraki bölümde inceleyeceğiz. Günah Keçisi Ağacı’nda sil(x) uygulaması çok basittir. Önce x de- ğerini ararız, sonra İkili Arama Ağacı’nın standart silme algoritmasını kullanarak sileriz (Unutmayın ki, bu işlem, ağacın yüksekliğini hiçbir zaman artıramaz). Sonra, n değişkenini 1 azaltır, q değişkenini aynen bırakırız. En sonunda, q 2n eşitsizliğini kontrol ede- riz, ve eğer öyleyse, ağacın tümünü, mükemmel dengeli İkili Arama Ağacı halinde yeniden yapılandırırız, ve q=n olarak belirleriz. Yine, yeniden yapılandırma maliyeti önemsenmediği takdirde, sil(x) işleminin çalışma zamanı ağacın yüksekliği ile orantılıdır, ve bu nedenle O(log n) zamanda çalışır. 290| | 291 Doğruluk Analizi ve Çalışma Zamanı Bu bölümde Günah Keçisi Ağacı işlemlerinin doğruluğunu ve amortize çalışma zamanlarını analiz edeceğiz. İlk olarak, doğruluğunu kanıtlamak için, ekle(x) işlemi, (8.1) koşulunu sağlamayan bir düğüm ile sonuçlanırsa, her zaman bir günah keçisi bulabileceğimizi göstereceğiz. Önerme 8.1. Günah Keçisi Ağacı’nda derinliği h > log3/2 q olan bir düğüm u ile verilsin. u’dan köke giden yol üzerinde aşağıdaki koşulu sağlayan bir w düğümü bulunur: Kanıt. Bu bağlamda çelişki uğruna, u’dan köke giden yol üzerindeki bütün w düğümleri için, olduğunu varsayalım. Kökten u’ya giden yol r = u0,…, uh = u ile ifade edilsin. O zaman, , ve daha genel olarak, 292| Ancak boyut(u) ≥ 1 olduğu için bu bir çelişki verir, dolayısıyla, Ardından, çalışma zamanının henüz açıklanmamış bileşenlerini analiz edeceğiz. İki bölümü vardır: Günah keçisi düğümlerini ararken boyut(u) için yapılan çağrıların maliyeti ve günah keçisi, w’yi bulduğumuzda yeniden_oluştur(w) için yapılan çağrıların maliyeti, boyut(u) ve yeniden_oluştur(w) için yapılan çağrıların maliyeti ile aşağıdaki şekilde ilişkili olabilir: Önerme 8.2. Günah Keçisi Ağacı’nda ekle(x) için yapılan çağrı sırasında, günah keçisi w’yi bulmanın, ve w kökenli altağacı yeniden yapılandırmanın maliyeti O(boyut(w)) olur. Kanıt. w günah keçisi düğümünü bulduktan sonra, onu yeniden yapılandırmanın maliyeti O(boyut(w)) olur. Günah keçisi düğümünü ararken günah keçisi olan uk = w bulunana kadar, u0,...,uk düğüm dizisi üzerinde boyut(u) çağrısı yaparız. Ancak, bu dizide günah keçisi olan ilk düğümün uk olması nedeniyle, her i {0,…,k–2} için, | 293 geçerli olduğunu biliyoruz. Bu nedenle, boyut(u) için yapılan tüm çağrıların maliyeti, olarak hesaplanır. Kanıtın son satırında, toplamın aslında geometrik azalan bir dizi olması gerçeğinden faydalandık. Önerme 8.3. Boş bir Günah Keçisi Ağacı ile başlandığında, m defa çağrılan ekle(i, x) ve sil(i) işlemleri sırasında yapılan yeniden_oluştur(u) çağrıları, en fazla O(m log m) toplam zamanda çalışır. Kanıt. Bunu kanıtlamak için kredi şemasını kullanacağız. Her düğümün bir miktar kredi depoladığını düşünelim. Her kredi, yeniden yapılandırma için harcanan birim zamanı, c sabitiyle öder. Bu şema O(m log m) toplam kredi gerektirir ve yeniden yapılandırma için yapılan her çağrı, u düğümünde saklanan kredilerle ödenir. 294| Ekleme veya silme sırasında, eklenen veya silinen düğüme giden yol üzerindeki her düğüme 1 kredi veririz. Bu şekilde, işlem başına en fazla log3/2 q ≤ log3/2 m kredi veririz. Silme sırasında, ayrıca ek bir kredi saklarız. Böylece toplam olarak, O(m log m) kredi bildiririz. Geriye kalan, bu kredilerin yeniden_oluştur(u) için yapılan tüm çağrıları ödemeye yeterli olduğunu göstermektir. Ekleme sırasında yeniden_oluştur(u) çağrılırsa, bunun nedeni u’nun günah keçisi olmasıdır. Genelleme kaybına girmeden varsa- yalım ki, Aşağıdaki bağıntı gerçeğinden, çıkarabiliriz ki, ve bu nedenle, | 295 Şimdi, u içeren bir altağaç, en son olarak yeniden yapılandırıldığında (veya u eklendiği zaman, u içeren bir altağaç, hiçbir zaman yeniden yapılandırılmamışsa), doğrudur. Bu nedenle, o zamandan itibaren u.left ve u.right altağaçlarını etkileyen ekle(x) veya sil(x) işlem sayısı, en az, olur ve böylece, u düğümünde depolanan, ve yeniden_oluştur(u) çağrısı için gerekli O(boyut(u)) zamanı ödemek için, en az bu kadar yeterli kredimiz vardır. Silme sırasında, q 2n olduğu zaman yeniden_oluştur(u) çağrısı yaparız. Bu durumda, ayrıca depolanmış bulunan q – n n kredi- ye sahibiz ve bu kredileri, kökü yeniden yapılandırmak için gerekli O(n) zamanı ödemek için kullanırız. Bu kanıtı tamamlar. 296| Özet Teorem 8.1. Aşağıdaki teorem Günah Keçisi Ağacı veri yapısının performansını özetlemektedir: Günah Keçisi Ağacı, Sıralı Küme den_oluştur(u) arayüzünü uygular. yeni- işlemi için yapılan çağrıların maliyeti önemsenme- diği takdirde, Günah Keçisi Ağacı işlem başına O(log n) zamanda çalışan ekle(x), sil(x) ve bul(x) işlemlerini destekler. Başlangıçta, Günah Keçisi Ağacı düğümleri boş değer taşırken, m defa çağrılan ekle(i, x) ve sil(i) işlemleri sırasında yapılan yeniden_oluştur(u) çalışır. çağrıları, en fazla O(m log m) toplam zamanda | 297 Tartışma ve Alıştırmalar Günah Keçisi Ağacı, Galperin ve Rivest [33] tarafından tanımlan- mış ve analiz edilmiştir. Ancak, aynı yapı, Genel Dengeli Ağaçlar adıyla Andersson [5, 7] tarafından daha önce keşfedilmiştir. Bu yapı, yüksekliği küçük olduğu sürece herhangi bir şekil alabilir. Günah Keçisi Ağacı uygulaması ile yapılacak denemeler, genellikle onların, bu kitaptaki diğer Sıralı Küme uygulamalarından çok daha yavaş olduğunu ortaya koyacaktır. Bu biraz şaşırtıcı olabilir, çünkü yükseklik sınırı, bir Sekme Listesi’ndeki arama yolunun beklenen uzunluğundan daha iyidir ve Treap’inkinden de çok fazla değildir. Alt ağaçların boyutlarını her düğümde açıkça depolayarak veya zaten hesaplanmış bulunan altağaç boyutlarını yeniden kullanarak (Alıştırma 8.5 ve 8.6) uygulamayı optimize edebilirsiniz. Bu iyileştirmelerle bile de olsa, her zaman için, Günah Keçisi Ağacı’nda çalıştırılan bir dizi ekle(x) ve sil(x) işlemi, diğer Sıralı Küme uygulamalarından daha uzun zaman alır. Bu performans açığı, kitapta tartışılan diğer Sıralı Küme uygulamalarının aksine, bir Günah Keçisi Ağacı’nın kendisini yeniden yapılandırırken aslında çok zaman harcamasına bağlıdır. Alıştırma 8.3, 298| n işlem dizisi için Günah Keçisi Ağacı’nın yeniden_oluştur(u) için yapılan çağrılar sırasında n log n derecesinde zaman harcadığını kanıtlamanızı istiyor. Bu gerçek, kitabımızda anlatılan diğer Sıralı Küme uygulamalarının aksine, n işlem dizisi sırasında O(n) yapısal değişiklik yapılmasını gerektirir. Bu, ne yazık ki, Günah Keçisi Ağacı’nın yeniden yapılandırmayı tamamen yeniden_oluştur(u) için yaptığı çağrılarla gerçekleştirmesinin getirdiği kaçınılmaz bir sonuçtur. [20]. Performansı iyi olmamasına rağmen, Günah Keçisi Ağacı bazı uygulamalar için doğru seçim olacaktır. Döndürüş sonrasında sabit zamanda güncellenemeyen, ancak yeniden_oluştur(u) işlemi sırasında güncellenebilen düğümler ile ilişkili, ek veriler olduğu zaman tercih edilebilir. Bu gibi durumlarda, Günah Keçisi Ağacı ve kısmi yeniden yapılandırmaya dayalı ilgili yapılar işe yarayabilir. Böyle bir uygulama örneği Alıştırma 8.11’de gösterilmiştir. Alıştırma 8.1. Şekil 8.1’de verilen Günah Keçisi Ağacı’na 1,5 ve 1,6 değerlerinin eklenmesini gösterin. Alıştırma 8.2. Boş bir Günah Keçisi Ağacı’na 1, 5, 2, 4, 3 dizisini eklediğinizde ne olduğunu gösterin. Önerme 8.3’ün kanıtında kredilerin nereye harcandığını ve bu verileri eklerken kredilerin nasıl kullanıldığını açıklayın. Alıştırma 8.3. Boş bir Günah Keçisi Ağacı ile başlandığında, ve x = 1, 2, 3, ...,n için ekle(x) işlemini çağırdığınızda, yeni- | 299 den_oluştur(u) için yapılan çağrılar sırasında, bazı sabit c 0 için çalışma zamanının en az cn log n olduğunu gösterin. Alıştırma 8.4. Günah Keçisi Ağacı, arama yolunun, bu bölümde anlatıldığı gibi, log3/2 q uzunluğunu aşmayacağını garanti eder. 1. 1 < b < 2 aralığında verilen bir b parametresi için arama yolu uzunluğu en fazla logb q olan, değiştirilmiş bir Günah Keçisi Ağacı versiyonunu tasarlayın, analiz edin ve uygula- yın. 2. Analiziniz ve/veya deneyleriniz, n ve b cinsinden birer fonksiyon olarak, bul(x), ekle(x) ve sil(x) işlemlerinin amortize maliyetleri hakkında ne söylemektedir? Alıştırma 8.5. Günah Keçisi Ağacı’nın ekle(x) yöntemini değiştirin. Yeni versiyon, zaten hesaplanmış olan altağaçların boyutlarını tekrar hesaplamak için zaman harcamamalıdır. Bu mümkündür, çünkü, boyut(w) değerini hesaplamak istediğiniz zaman, boyut(w.left) veya boyut(w.right)’dan birini zaten hesaplamış olma- nız gerekir. Değiştirdiğiniz uygulama ile bu bölümde verilen uygulamanın performansını karşılaştırın. Alıştırma 8.6. Günah Keçisi Ağacı veri yapısının ikinci bir versiyonunu uygulayın. Her bir düğüm, o düğümde kökenli altağacın boyutunu açıkça depolamalıdır. Bu uygulamanın performansını, orijinal Günah Keçisi Ağacı uygulaması ile, ve bunun yanı sıra, Alıştırma 8.5’te değiştirdiğiniz uygulama ile karşılaştırın. 300| Alıştırma 8.7. Bu bölümün başında tartışılan yeniden_oluştur(u) yöntemini yeniden uygulayın. Bu uygulamada, yeniden yapılandırılacak altağacın düğümlerini saklayan bir dizinin kullanımı gerekli değildir. Bunun yerine, düğümleri önce bir bağlantılı liste halinde birleştirmek için özyineleme kullanın, ve sonra bu bağlantılı listeyi mükemmel dengeli ikili ağaca dönüştürün (İki adımın da çok iyi özyinelemeli uygulamaları vardır). Alıştırma 8.8. Ağırlıklı Dengeli Ağacı analiz edin ve uygulayın. Kök dışında, her u düğümü, boyut(u) (2/3) boyut(u.parent) ile verilen denge değişmezini korur. ekle(x) ve sil(x) işlemleri standart İkili Arama Ağacı işlemleri ile aynıdır. Ancak, herhangi bir u dü- ğümünde denge değişmezi ihlal edildiğinde, u.parent kökenli altağaç yeniden yapılandırılır. Analiziniz, Ağırlıklı Dengeli Ağaç işlemlerinin O(log n) amortize zamanda çalıştığını göstermelidir. Alıştırma 8.9. Geri Sayım Ağacı’nı analiz edin ve uygulayın. Her u düğümü u.t zamanlayıcısını tutar. ekle(x) ve sil(x) işlemleri standart İkili Arama Ağacı işlemleri ile aynıdır. Ancak, bu işlemlerden biri u’nun altağacını etkilediği zaman, u.t 1 azaltılır. u.t = 0 iken, u kökenli altağacın tümü mükemmel dengeli ikili ağacı halinde yeniden yapılandırılır. u düğümü, yeniden yapılandırma işlemine dahil edildiyse (u veya u’nun atalarından biri yeniden yapılandırıldıysa), u.t değeri boyut(u) / 3 olarak ayarlanır. | 301 Analiziniz, Geri Sayım Ağacı işlemlerinin O(log n) amortize zamanda çalıştığını göstermelidir. (İpucu: Öncelikle, her u düğümünün denge değişmezinin bazı versiyonunu sağladığını gösterin.) Alıştırma 8.10. Dinamit Ağacı’nı analiz edin ve uygulayın. Her u düğümü u.boyut değişkeninde u kökenli altağacın boyutunu tutar. ekle(x) ve sil(x) işlemleri standart İkili Arama Ağacı işlemleri ile aynıdır. Ancak, bu işlemlerden biri u’nun altağacını etkilediği zaman, 1 / u.boyut olasılıkla u patlar. u patladığında, altağacının tümü mükemmel dengeli ikili ağacı halinde yeniden yapılandırılır. Analiziniz, Dinamit Ağacı işlemlerinin O(log n) beklenen zamanda çalıştığını göstermelidir. Alıştırma 8.11. Bir dizi (liste) elemanı saklayan Sekans veri yapısını tasarlayın ve uygulayın. Aşağıdaki işlemleri destekler: ardındanEkle(e): Dizide e elemanından sonra yeni bir eleman ekler. Yeni eklenen elemanı döndürür. (e, null ise, yeni eleman dizinin başlangıcına eklenir.) sil(e): önceGelen(e1, e2): Diziden e elemanını siler. Dizide e1 elemanı, e2’den önce geliyorsa, true döndürür. İlk iki işlem O(log n) amortize zamanda çalışmalıdır. Üçüncü işlem sabit zamanda çalışmalıdır. 302| Sekans Günah veri yapısının elemanlarını, dizide oluştukları sırada, bir Keçisi önceGelen(e1, e2) Ağacı’nda saklayarak uygulayabilirsiniz. işlemini sabit zamanda gerçekleştirmek için, her e elemanı kökten başlayıp e’ye giden yolu şifreleyen bir tamsayıyla etiketlenir. Bu şekilde, önceGelen(e1, e2), e1 ve e2 etiketlerini karşılaştırarak sonuç döndürür. | 303 304| Bölüm 9 Kırmızı-Siyah Ağaçlar Bu bölümde, İkili Arama Ağacı’nın logaritmik yükseklikli bir versiyonu olan Kırmızı-Siyah Ağacı tanıtıyoruz. Kırmızı-Siyah Ağacı, en yaygın kullanılan veri yapılarından biridir. Java Koleksiyonları Çerçevesi ve C++ Standart Şablon Kütüphanesi’nin çeşitli uygulamaları da dahil olmak üzere, pek çok kütüphane uygulamasında birincil arama yapısı olarak görünür. Linux işletim sistemi çekirdeği içinde de kullanılmaktadır. Kırmızı-Siyah Ağaç’larının popüler olmasının çeşitli nedenleri vardır: 1. n değer depolayan bir Kırmızı-Siyah Ağacı, en fazla n 2log yüksekliğe sahiptir. 2. ekle(x) ve sil(x) işlemleri, Kırmızı-Siyah Ağacı üzerinde O(log n) en kötü zamanda çalışır. 3. ekle(x) ve sil(x) işlemleri sırasında amortize sabit sayıda döndürüş gerçekleştirilir. Bu özelliklerin ilk ikisi, Kırmızı-Siyah Ağacı’nı zaten Sekme Listeleri, Treap ve Günah Keçisi Ağacı’nın bir adım önüne koymaktadır. Sekme Listeleri ve Treap, rasgeleliğe dayanır ve O(log n) sadece beklenen çalışma zamanıdır. Günah Keçisi Ağacı’nın yükseklik | 305 sınırı garantilidir, ancak ekle(x) ve sil(x) işlemleri, sadece O(log n) amortize zamanda çalışır. Üçüncü özellik, x elemanını eklemek veya silmek için gerekli zamanın, x’i bulmak için gerekli zaman tarafından gölgede bırakıldığını bize anlatıyor. Ancak Kırmızı-Siyah Ağaç’ların iyi özelliklerinin bir bedeli vardır: uygulama karmaşıklığı. Yüksekliğin 2log n ile sınırlanması kolay değildir. Birkaç durumun dikkatli analizini gerektirir. Uygulama, her durumda tam olarak doğru şeyi yapmalıdır. Yanlış bir döndürüş veya renk değişikliği, anlaşılması ve izlenmesi çok zor bir hata üretir. Kırmızı-Siyah Ağaç’ların uygulamasına doğrudan atlamadan önce, nasıl keşfedildiklerine ve neden verimli bakıldıklarına dair kavrayış ve anlayış sağlayacak bir veri yapısı hakkında bilgi vereceğiz: 2-4 Ağaçları. 306| 2-4 Ağaçları 2-4 Ağacı aşağıdaki özelliklere sahip köklü bir ağaçtır: Özellik 9.1 (yükseklik). Bütün yapraklar aynı derinliğe sahiptir. Özellik 9.2 (derece). Her iç düğümün çocuk sayısı 2, 3 veya 4’tür. Şekil 9.1, 2-4 Ağacı’na bir örnek göstermektedir. 2-4 Ağacı’nın özellikleri, yüksekliğin, yaprak sayısı ile logaritmik olarak bağıntılı olduğunu anlatır: Önerme 9.1. n yapraklı 2-4 Ağacı en fazla log n yüksekliğe sahiptir. Kanıt. İç düğüm üzerindeki en az 2 çocuk alt sınırı, h yükseklikli bir 2-4 Ağacı’nın en az 2h yaprağa sahip olması anlamına gelir. Bir başka deyişle, Her iki tarafın logaritmasını alarak h ≤ log n elde ederiz. | 307 Yaprak eklenmesi 2-4 Ağacı’na yaprak eklemek kolaydır (bkz. Şekil 9.2). Sondan bir önceki seviyede bulunan w düğümünün çocuğu olarak u yaprağını eklemek isterseniz, u’yu direkt olarak w’nin çocuğu yaparız. Yükseklik özelliği kesinlikle korunur, ancak derece özelliği bozulabilir; çünkü u eklenmeden önce w’nin 4 çocuğu varsa, şimdi 5 çocuğu olacaktır. Bu durumda, w, sırasıyla iki ve üç çocuğa sahip olan w ve w’ düğümleri olarak iki düğüm halinde ikiye bölünür. Ancak şimdi w’ düğümünün babası yoktur, bu yüzden özyinelemeli olarak w’nin babasının çocuğu olarak w’ yapılır. Böylece yine, w’nin ba- bası çok fazla çocuğa sahip olabilir, bu durumda bölünmelidir. Dört çocuktan daha az olan bir düğüme ulaşana kadar bu süreç devam eder veya kök r, iki düğüm halinde, r ve r’, olarak bölünür. Sonraki durumda, çocukları r ve r’ olan yeni bir kök oluştururuz. Her yaprağın derinliği böylece artar ve yükseklik özelliği korunur. 2-4 Ağacı’nın yüksekliği log n’den daha fazla olmayacağı için, yaprak ekleme süreci en fazla log n adım alır. 308| | 309 Yaprak silinmesi 2-4 Ağacı’ndan u’nun yaprak silmek biraz daha zordur (bkz. Şekil 9.3). babası olan w’den silmek için, u’yu sadece sileriz. u silin- meden önce, w sadece iki çocuğa sahipse, o zaman w bir çocukla kalır, ve derece özelliği bozulur. Bunu düzeltmek için, w’nin kardeşi olan w’ düğümüne bakılır. w’ düğümü ağaçta mutlaka bulunmalıdır, çünkü silme işleminden önce, w’ babası en az iki çocuğa sahipti. w’ üç veya dört çocuğa sahip ise, bu çocuklardan birini w’ düğümünden alırız ve w’ye veririz. Şimdi w’nin iki çocuğu vardır, ve w' düğümünün iki veya üç çocuğu vardır; işlem tamamlanır. Öte yandan, eğer w’ yalnızca iki çocuk sahibiyse, w ve w’ düğümlerini üç çocuklu tek bir w düğüm halinde birleştiririz. Ardından, özyinelemeli olarak, w’ babasından w’ düğümünü sileriz. Bu süreç kendisinin veya kardeşinin ikiden fazla çocuğu olması durumunu sağlayan bir u düğümüne, veya köke ulaşıldığında sona erer. Sonraki durumda, kök sadece bir çocuk ile kalmışsa, kökü sileriz, ve çocuğunu yeni kök yaparız. Yine, her yaprağın yüksekliği azalır, ve böylece yükseklik özelliği korunur. 310| Yine, ağacın yüksekliği en fazla log n olacağı için, yaprak silme işlemi en fazla log n adımdan sonra tamamlanır. | 311 Kırmızı-Siyah Ağacı: 2-4 Ağacının Benzeri Kırmızı-Siyah Ağaç, her, u düğümü kırmızı veya siyah renk alan İkili Arama Ağacı’dır. Kırmızı renk 0 ile, ve siyah renk 1 ile temsil edilir. Kırmızı-siyah ağaç üzerinde gerçekleştirilen herhangi bir işlem öncesi ve sonrasında, aşağıdaki iki özellik sağlanmalıdır. Her özellik, 0 ve 1 sayısal değerlerini alan, kırmızı ve siyah renk cinsinden tanımlanır. Özellik 9.3 (siyah-yükseklik). Kökten yaprağa giden her yol üzerindeki siyah düğüm sayısı aynıdır. (Kökten yaprağa giden her yol üzerindeki renk toplamı aynıdır.) Özellik 9.4 (komşu-olmayan-kırmızı-kenar). İki kırmızı düğüm bitişik olamaz. (Kök dışında, herhangi, u.colour + u.parent.colour ≥ 1 u, düğümü için, olur.) Unutmayın ki, bu iki özellikten hiçbirini bozmadan, Kırmızı-Siyah Ağacı’nın, r, kökünü renklendirebiliriz, kökün siyah renkte olduğu- 312| nu ve ağacı güncelleyen algoritmaların bunu koruduğunu varsayacağız. Kırmızı-Siyah Ağacı’nı kolaylaştıran bir başka fikir de, (nil ile gösterilen) dış düğümleri siyah düğüm olarak değerlendirmektir. Bu şekilde, Kırmızı-Siyah Ağacı’nın her gerçek, u düğümü, renkleri iyi tanımlanmış olan tam olarak iki çocuğa sahip olur. Şekil 9.4 Kırmızı-Siyah Ağacı’na bir örnek gösteriyor. | 313 Kırmızı-Siyah Ağacı ve 2-4 Ağacı İlk bakışta, Kırmızı-Siyah Ağacı’n siyah-yükseklik ve komşuolmayan-kırmızı-kenar özelliklerini sağlayacak şekilde verimli olarak güncellenebilir olması şaşırtıcı görünebilir. Oysa ki, kırmızısiyah ağaçlar birer ikili ağaç olan 2-4 ağaçlarının verimli bir simulasyonu olarak tasarlanmıştı. Şekil 9.5’e bakarak, n düğümlü herhangi bir kırmızı-siyah ağacı, T’yi ele alın, ve aşağıdaki dönüşümü gerçekleştirin: Her u kırmızı düğümünü silin, ve u’nun iki çocuğunu u’nun (siyah) babasına direkt olarak bağlayın. Bu dönüşüm sonrasında sadece siyah düğümlere sahip olan bir T' ağacıyla başbaşa kalırız. T' ağacının her iç düğümü, iki, üç veya dört çocuğa sahiptir: İki siyah çocuk ile başlayan siyah bir düğüm, bu dönüşümden sonra da, iki siyah çocuk sahibi olacaktır. Bir kırmızı ve bir siyah çocuk 314| ile başlayan siyah bir düğüm, bu dönüşüm sonrasında, üç çocuk sahibi olacaktır. İki kırmızı çocuk ile başlayan siyah bir düğüm, bu dönüşümden sonra dört çocuk sahibi olacaktır. Ayrıca, siyahyükseklik özelliği, kökten-yaprağa giden her yolun T' içinde aynı uzunlukta olmasını garanti eder. Diğer bir deyişle, T', 2-4 ağacıdır! 2-4 ağacı olan T', n + 1 yaprağa sahiptir. Bu nedenle, bu ağacın yüksekliği en fazla log(n + 1) olur. Şu anda, 2-4 ağaçta, kökten yaprağa giden her yol, kırmızı-siyah ağaçta, kökten bir dış düğüme giden bir yola karşılık gelir. Bu yolun ilk ve son düğümü siyahtır, ve her iki iç düğümden en çok biri kırmızıdır, böylece bu yolun en fazla log(n + 1) siyah düğümü ve en fazla log(n + 1) – 1 kırmızı düğümü bulunmaktadır. Bu nedenle, T içinde, kökten T’nin bir iç düğümüne giden yol en fazla, uzunluğa sahipir (herhangi bir n ≥ 1 için). Bu, Kırmızı-Siyah Ağaç’ların en önemli özelliğini kanıtlar: Önerme 9.2. n düğümlü kırmızı-siyah ağacın yüksekliği en fazla 2log n olur. | 315 2-4 Ağaç ve Kırmızı-Siyah Ağaç’lar arasındaki ilişkiyi anladığımız için, eleman ekleme ve silme sırasında, kırmızı-siyah ağacın bakımını verimli şekilde sağlamak konusunda zorluk yaşanmayacaktır. İkili Arama Ağacı’na eleman eklemenin, yeni bir yaprak ekleyerek yapılabildiğini daha önce görmüştük. Bu nedenle, Kırmızı-Siyah Ağaç üzerinde ekle(x) işlemini uygulamak için, 2-4 Ağacı’nın beş çocuklu bir düğümünü ayırarak bölmeliyiz. 316| 2-4 Ağacı’nın beş çocuklu bir düğümü, iki kırmızı çocuğu olan siyah bir düğüm tarafından temsil edilir, bu iki kırmızı çocuktan birinin çocuğu da kırmızıdır. Bu halde, siyah düğümü kırmızı ile renklendirerek, ve iki çocuğu da siyah ile renklendirerek bu düğümü “ikiye böleriz”. Şekil 9.6 örnek bir uygulamayı gösteriyor. | 317 Benzer şekilde, sil(x) uygulaması, iki düğümü birleştiren ve kardeşten bir çocuk borçlanan bir işlemi gerektirir. İki düğümü birleştirmek, onları ortadan bölmenin (Şekil 9.6’da gösterilmiştir) zıt işlemidir, ve iki (siyah) kardeşin kırmızı ile renklendirilmesini, ve (kırmızı) babasının siyah ile renklendirilmesini içerir. Bir kardeşten borçlanma en zor işlemdir ve döndürüşler ile yeniden renklendirmeyi gerektirir. Tabii ki, tüm bunlar boyunca siyah-yükseklik ve komşu-olmayankırmızı- kenar özelliğini korumamız gerekiyor. Bunun yapılabilir olması artık şaşırtıcı olmasa da, özellikle Kırmızı-Siyah Ağacı’nı bir 2-4 Ağacı’na benzetirseniz, dikkate alınması gereken çok sayıda durum vardır. Bir noktada, 2-4 Ağacı’nı yalnızca göz ardı etmeniz, ve Kırmızı-Siyah Ağacı’nın özelliklerini sağlamaya çalışmanız daha kolay olacaktır. 318| Kırmızı-Siyah Ağacında Sola-Dayanım Kırmızı-Siyah Ağacı’nın le(x) tek bir tanımı yoktur. Daha doğrusu, ek- ve sil(x) işlemleri sırasında siyah-yükseklik ve komşu- olmayan-kırmızı-kenar özelliklerini koruyan ve yöneten birtakım yapılar vardır. Farklı yapılar bunu farklı şekillerde yaparlar. Burada, Kırmızı-Siyah Ağaç adı altında bir veri yapısını uyguluyoruz. Bu yapı, ek bir özelliği de sağlayan, kırmızı-siyah ağacın belirli bir varyasyonunu uygulamaktadır: Özellik 9.5 (sola-dayanım). Herhangi bir, u düğümünde, u.left siyah ise, u.right siyahtır. Fark edebilirsiniz ki, Şekil 9.4’de gösterilen Kırmızı-Siyah Ağaç sola-dayanım özelliğini sağlamıyor; bu özellik en sağdaki yol üzerindeki kırmızı düğümün babası tarafından bozulmuştur. Sola-dayanım özelliğini sağlamamızın nedeni, ekle(x) ve sil(x) işlemleri sırasında, ağacı güncellerken oluşabilecek durum sayısını azaltmaktır. 2-4 Ağacı açısından bu, her 2-4 Ağacı’nın tekil ve benzersiz gösterilmesi anlamına gelir: Bir düğüm, iki derecesindeyse, iki siyah çocuklu bir siyah düğüm haline gelir. Bir düğüm, üç derecesindeyse, sol çocuğu kırmızı ve sağ çocuğu siyah olan siyah bir düğüm haline gelir. Bir düğüm, dört derecesindeyse, iki kırmızı çocuklu siyah bir düğüm haline gelir. | 319 ekle(x) ve sil(x) uygulamasını ayrıntılı olarak anlatmadan önce, bu yöntemler tarafından kullanılan ve Şekil 9.7’de gösterilen bazı basit altprogramları sunacağız. İlk iki altprogram renkleri değiştirmek için kullanılırken, siyah-yükseklik özelliğini korur. pushBlack(u) işlemi, iki kırmızı çocuğu olan siyah bir u düğümünü girdi olarak alır, ve kendisini kırmızı ile, çocuklarını siyah ile renklendirir. pullBlack(u) işlemi, bu işlemi tersine çevirir: solaÇevir(u) yöntemi, u ve u.right düğümlerinin renklerini değişti- rir, ve sonra u düğümünde sola döndürüş gerçekleştirir. Bu işlem, 320| bu iki düğümün renklerini değiştirmesinin yanı sıra, baba-çocuk ilişkisini de tersine çevirir: solaÇevir(u) işleminin yararı, sola-dayanım özelliğini bozan u dü- ğümündeki (u.left siyah ve u.right kırmızı olduğu için) soladayanımı, tekrar geri kazandırmasıdır. Bu özel durumda, bu işlemin hem siyah-yükseklik ve hem de komşu-olmayan-kırmızı-kenar özelliğini koruyacağından emin olabiliriz. sağaÇevir(u) işlemi, solaÇevir(u) ğişmiştir. işlemi ile simetriktir, sağ ve sol roller sadece yer de- | 321 Ekleme Kırmızı-Siyah u.x = x, Ağaç üzerinde ekle(x) yöntemini uygularken, ve u.colour = red olacak şekilde yeni bir u yaprağı ekle- mek için, standart İkili-Arama Ağacı eklemesi yaparız. Unutmayın ki bu, hiçbir düğümün siyah yüksekliğini değiştirmez, böylece siyah-yükseklik özelliği bozulmaz. Ancak, sola-dayanım özelliği (u, babasının sağ çocuğu ise) ve komşu-olmayan-kırmızı-kenar özelliği bozulabilir (u’nun babası kırmızı ise). Bu özellikleri geri kazanmak için, ekleTamiri(u) yöntemini çalıştırırız. Şekil 9.8’de gösterilen, ekleTamiri(u) yöntemi, girdi olarak rengi kırmızı olan ve komşu-olmayan-kırmızı-kenar özelliğini ve/veya sola-dayanım özelliğini bozabilecek u düğümünü alır. Bu işlem ile ilgili tartışmayı takip edebilmeniz için, Şekil 9.8’e başvurmanız veya bir parça kağıt üzerinde canlandırmalar yapmanız gerekmektedir. Nitekim, okuyucu devam etmeden önce, bu şekilleri incelemek isteyecektir. 322| u ağacın kökü ise, her iki özelliği de sağlaması için rengini siyah olarak belirleyebiliriz. Aynı zamanda, u’nun kardeşi kırmızı ise, u’nun babası siyah olmalıdır, bu nedenle sola-dayanım ve komşu- olmayan-kırmızı-kenar özelliklerinin her ikisi de zaten sağlanır. Aksi takdirde, ilk olarak u’nun babası, w’nin, sola-dayanım özelliğini bozup bozmadığını belirleriz ve eğer öyleyse, solaÇevir(u) işlemi çalıştırılır ve u = w olarak belirlenir. Bu bizi iyi tanımlanmış bir duruma götürür: u, babası olan w’nin sol çocuğudur, böylece şimdi, w sola-dayanım özelliğini sağlar. Geriye, komşu-olmayan- | 323 kırmızı-kenar özelliğini sağlamak kalıyor. Sadece, w’nin kırmızı olduğu durum hakkında endişelenmeliyiz, çünkü u komşuolmayan-kırmızı-kenar özelliğini aksi takdirde zaten sağlamaktadır. Henüz işimizi bitirmediğimiz için, u kırmızı ve w kırmızı olarak kalmıştır. Komşu-olmayan-kırmızı-kenar özelliği, u’nun büyükannesi g’nin var olduğunu ve onun siyah olduğunu öngörmektedir. g’nin sağ çocuğu kırmızı ise, o zaman sola-dayanım özelliği g’nin her iki çocuğunun da kırmızı olduğunu garanti eder, ve pushBlack(g) için yapılan bir çağrı, g’yi kırmızı ve w’yi siyah ya- par. Böylece komşu-olmayan-kırmızı-kenar özelliği, u düğümünde yeniden kazanılır, ancak g düğümünde bu özellik bozulabileceği için, sürecin tamamı u = g için yeniden başlatılır. g’nin sağ çocuğu siyah ise, sağaÇevir(g) için yapılan bir çağrı w düğümünü g’nin (siyah) babası yapar, w’nin iki kırmızı çocuğu oluşur: u ve g. Böylece u’nun komşu-olmayan-kırmızı-kenar özelliğini sağlaması ve g’nin sola-dayanım özelliğini sağlaması garanti altına alınır. Bu durumda, hiçbir şey yapmayız. 324| ekleTamiri(u) yöntemi işlem başına sabit zamanda çalışır, ve her bir yineleme ya işlemi sonlandırır, veya u pozisyonunu köke doğru yakına taşır. Bu nedenle, ekleTamiri(u) işlemi O(log n) döngüden sonra O(log n) zamanda çalışmasını sona erdirir. | 325 Silme Kırmızı-Siyah Ağaç üzerinde sil(x) uygulaması en karmaşık işlem- dir, ve bilinen tüm kırmızı-siyah ağaç varyasyonları için bu böyledir. İkili Arama Ağacı’ndaki sil(x) işleminde olduğu gibi, sadece u çocuklu, bir w düğümünü buluruz ve, w.parent = u belirlemesiyle w’yi ağaçtan ayırırız. Buradaki problem, w siyah ise, siyah-yükseklik koşulu, w.parent düğümünde u.colour bozulmuştur. Bu sorunu geçici olarak, += w.colour belirlemesiyle, önleyebiliriz. Tabii ki, bu iki diğer problemi beraberinde getirir: 1. u ve w siyah ile başlamışsa, u.colour + w.colour = 2 (iki-kat- siyah), geçersiz renk olarak belirlenir. 2. w kırmızı ise, siyah u düğümü tarafından yer değiştirilir, ki bu da u.parent düğümünde sola-dayanım özelliğini bozar. Her iki problem de silTamiri(u) işlemine yapılan bir çağrı ile çözülebilir. silTamiri(u) yöntemi girdi olarak rengi (1) siyah ve (2) iki-kat- siyah olan bir u düğümü alır. u iki-kat-siyah ise, silTamiri(u), ikikat-siyah düğüm ağaç seviyelerinde yukarı çıkarılarak yok edilene kadar bir dizi döndürüş ve yeniden renklendirme gerçekleştirir. Bu işlem sırasında, u düğümü, süreç sonunda, değiştirilen altağacın 326| köküne ait oluncaya kadar değişir. Bu altağacın kökü renk değiştirmiş olabilir. Özellikle, kırmızıdan siyaha geçmiş olabilir, böylece silTamiri(u) işlemi, u’nun babasının sola-dayanım özelliğini bozup bozmadığını kontrol ederek bitirir, ve eğer bozuyorsa, düzeltir. silTamiri(u) yöntemi Şekil 9.9’da gösterilmiştir. Şekil 9.9’a baş- vurmaksızın, aşağıdaki metni takip etmeniz imkansız olmasa da, çok zor olacaktır. | 327 silTamiri(u) yöntemindeki döngü, aşağıdaki durumlardan birine bağlı kalarak, iki-kat-siyah düğümleri işlemektedir: Durum 0: u köktür. İşlemesi en kolay durum budur. u siyah olarak yeniden renklendirilir (Kırmızı-siyah ağaç özelliklerinin hiçbiri bozulmaz). Durum 1: u’nun kardeşi olan v kırmızı renktedir. Bu durumda, u’nun kardeşi, babası olan w’nin sol çocuğudur (sola-dayanım özel- liği nedeniyle). w düğümünde sağa çevirme yaparız ve döngüye devam ederiz. Unutmayın ki, bu eylem sonucunda w’in babası soladayanım özelliğini bozar, ve u’nun derinliği artmıştır. Ancak, bir sonraki döngünün w kırmızı iken Durum 3 için işletileceği anlamına da gelir. Aşağıdaki 3.durumu incelediğinizde, bir sonraki döngüde sürecin sona ereceğini görebilirsiniz. 328| Durum 2: u’nun kardeşi olan v siyahtır. u, babası olan w’nin sol çocuğudur. Bu durumda pullBlack(w) için bir çağrı yaparak u siyah, v kırmızı, w siyah veya iki-kat-siyah renk alır. Bu noktada, w sola-dayanım özelliğini bozacağı için, solaÇevir(w) için yapılan bir çağrıyla bunu düzeltiriz. Bu andan itibaren, w kırmızı, v başladığımız altağacın köküdür. w’nin komşu-olmayan-kırmızı-kenar özelliğini bozup bozmadığını kontrol etmeliyiz. Bunu yapmak için, w’nin sağ çocuğu olan q’yi incelememiz gerekir. Eğer q siyah ise, w komşu-olmayan-kırmızıkenar özelliğini sağlar, ve bir sonraki döngüye u = v belirlemesiyle devam ederiz. Aksi takdirde, (q kırmızı iken), w, ve q düğümlerinde, sırasıyla, sola-dayanım ve komşu-olmayan-kırmızı-kenar özellikleri bozulmuştur. Sola-dayanım özelliğini, solaÇevir(w) için bir çağrı yaparak düzeltiriz, ancak, komşu-olmayan-kırmızı-kenar özelliği halen bozulmuştur. Bu noktada, q, v’nin sol çocuğudur, w, q’nin sol çocuğudur, q ve w her ikisi de kırmızıdır, v siyah veya iki-katsiyahtır. sağaÇevir(q) için yapılan bir çağrı ile q düğümü, hem v, hem w düğümlerinin babası olur. Bunu izleyen bir pushBlack(q) çağrısı, hem v, hem w düğümlerini siyah hale getirir, ve, q’nun rengini w’nin, orijinal rengi olarak belirler. | 329 Bu andan itibaren, iki-kat-siyah düğüm ortadan kaldırılmış, ve komşu-olmayan-kırmızı-kenar ve siyah-yükseklik özellikleri geri kazandırılmıştır. Sadece olası bir sorun vardır: v’nin sağ çocuğu kırmızı olabilir, ve sola-dayanım özelliği bozulur. Bu durumu kontrol eder, ve gerekiyorsa, solaÇevir(v) için yapılan bir çağrı ile özelliği geri kazandırırız. 330| Durum 3: u’nun kardeşi siyahtır. u, babası olan w’nin sağ çocuğudur. Bu durum, 2.Durum ile simetrik olduğu için benzer şekilde işlenir. Tek fark, sola-dayanım özelliğinin asimetrik olması nedeniyle farklı işlem gerektirmesidir. | 331 Önceki gibi, pullBlack(w) için yapılan bir çağrı ile başlarız ve bunun sonucunda, v kırmızı, u siyah olur. sağaÇevir(w) için yapılan bir çağrı sonucunda, v, altağacın kökü haline gelir. Bu noktada, w kırmızıdır, w’nin sol çocuğu olan q’nun rengine göre kod iki dala ayrışır. q kırmızı ise, kod 2.Durum’da olduğunun aynısı gibi ve hatta daha basit şekilde işler; v düğümünde sola-dayanım özelliğinin bozulması tehlikesi yoktur. 332| q siyah ise, durum daha karmaşıktır. Bu durumda, v’nin sol çocu- ğunun rengini kontrol ederiz. Kırmızı ise, v iki kırmızı çocuk sahibidir ve iki-kat-siyah olan v düğümü, pushBlack(v) çağrısı ile aşağı itilir. Bu noktada, v, w’nin orijinal rengine bürünür, işlem tamamlanır. v’nin sol çocuğu siyah ise, v sola-dayanım özelliğini bozar. solaÇevir(v) için yapılan bir çağrı ile bu özellik geri kazandırılır. Bir sonraki silTamiri(u) döngüsünü, u = v için çalıştırmak üzere, v düğümünü döndürürüz. | 333 silTamiri(u) işleminin her döngüsü sabit zamanda çalışır. Durum 2 ve 3, ya sonlanır, ya da u’yu ağaçta köke daha yakın yere taşır. Durum 0, (u kök olduğu için) her zaman sonlanır. Durum 1, Durum 3 haline gelerek hemen sonlanır. Ağacın yüksekliği en az 2log n olduğu için, silTamiri(u) işleminin en çok O (log n) döngü çalıştırdığı sonucuna varabilirsiniz, böylece silTamiri(u), O(log n) zamanda çalışır. 334| Özet Aşağıdaki teorem Kırmızı-Siyah Ağaç veri yapısının performansını özetlemektedir: Teorem 9.1. Kırmızı-Siyah Ağaç, Sıralı Küme arayüzünü uygular. Kırmızı-Siyah Ağaç, işlem başına O(log n) en-kötü zamanda çalışan, ekle(x), sil(x) ve bul(x) işlemlerini destekler. Aşağıda ekstra bir teorem daha verilmektedir: Teorem 9.2. Başlangıçta, Kırmızı-Siyah Ağaç elemanları boş değer taşırken, ekle(x) ve sil(x) için yapılan m çağrı sırasında, ekleTamiri(u) ve silTamiri(u) çağrıları O(m) toplam zamanda ça- lışır. Sadece Teorem 9.2’ın kanıtını açıklayacağız. ekleTamiri(u) ve silTamiri(u) algoritmalarını, 2-4 Ağacı’na yaprak ekleyen veya silen algoritmalar ile karşılaştırarak, bu özelliğin 2-4 Ağacı’ndan devralındığına kendimizi inandırabiliriz. Özellikle, 2-4 Ağacı’nı ayırmak, birleştirmek ve ödünç almak işlemlerinin O(m) toplam zamanda çalıştığını gösterebilirsek, o zaman bu Teorem 9.2 anlamına gelir. | 335 2-4 Ağacı için bu teoremin kanıtı, amortize analizin potansiyel metotunu kullanır. 2-4 Ağacı’nın iç düğümü olan u’nun potansiyeli, ve 2-4 Ağacı’nın potansiyeli, düğümlerin potansiyellerinin toplamı olarak tanımlansın. Bölünme oluştuğunda, dört çocuklu bir düğüm, iki ve üç çocuklu, ikişer düğüm haline gelir. Bunun anlamı, toplam potansiyel 3 – 1 – 2 = 2 kadar azalır. Birleştirme oluştuğunda, iki çocuğu olan iki düğüm, üç çocuklu bir düğüm ile yer değiştirir. Bunun anlamı, toplam potansiyel 2 – 0 = 2 kadar azalır. Bu nedenle, her bölünme veya birleştirme sonrasında potansiyel 2 azalır. Ardından, fark edebilirsiniz ki, düğümleri bölmeyi ve birleştirmeyi görmezden gelirseniz, sabit sayıdaki düğümlerin çocuk sayısı, bir yaprağın eklenmesi veya çıkarılması ile değişmektedir. Bir düğümü eklerken, bir düğümün çocuk sayısı 1 artar, bu da potansiyeli en fazla 3 artırır. Bir yaprağın silinmesi sırasında, bir düğümün çocuk sayısı 1 azalır, bu da potansiyeli en fazla 1 artırır, ve iki düğüm toplam borçlanma işlemine dahil edilebilir, bunun sonucunda toplam potansiyelleri en fazla 1 artar. Özetlemek gerekirse, her birleştirme ve bölme potansiyeli en az 2 azaltır. Birleştirme ve bölme önemsenmediği takdirde, her ekleme 336| veya silme, potansiyelin en fazla 3 artmasına neden olur, ve potansiyel her zaman pozitiftir. Bu nedenle, başlangıçta boş bir ağaç üzerinde yapılan m ekleme veya silmenin neden olduğu bölme ve birleştirmelerin sayısı, en fazla 3m / 2 olur. Teorem 9.2, bu analizin ve 2-4 Ağacı ile Kırmızı-Siyah Ağacı arasındaki benzeşmenin bir sonucudur. | 337 Tartışma ve Alıştırmalar Kırmızı-Siyah Ağacı ilk olarak Guibas ve Sedgewick [38] tarafın- dan tanıtıldı. Uygulaması karmaşık olmasına rağmen, en sık kullanılan kütüphane ve uygulamalar arasındadır. Algoritma ve veri yapıları üzerine çoğu ders kitabında, Kırmızı-Siyah Ağaç’ların bazı varyasyonları tartışılmaktadır. Andersson [6] dengeli ağaçların sola-dayanımlı bir versiyonunu açıklıyor. Bu yapı kırmızı-siyah ağaçlara benzer, ancak bir ek kısıtlama olarak, herhangi bir düğümünde en fazla bir adet kırmızı çocuğa yer vardır. Bu demektir ki, bu ağaçlar 2-4 Ağacı gibi değil, 23 Ağacı gibi davranırlar. Bunlar, bu bölümde tanıtılan Kırmızı- Siyah Ağaç yapısından önemli ölçüde daha kolaydır. Sedgewick [66] Kırmızı-Siyah Ağacı’nın sola-dayanımlı iki versiyonunu açıklıyor. Bunlar, 2-4 Ağacı’nda yukarıdan-aşağıya bölme ve birleştirme simülasyonu ile birlikte özyineleme kullanır. Bu iki tekniğin birleşimi özellikle kısa ve zarif kod yapar. İlgili ve daha eski bir veri yapısı AVL ağacı [3]’dır. AVL Ağaç’larının yüksekliği-dengelidir: Her u düğümünde, u.left köken- li ağacın yüksekliği ile u.right kökenli altağacın yüksekliği en fazla 1 farklıdır. h yükseklikli bir ağacın minimum yaprak sayısı F(h) ile verildiyse, o zaman F(h), aşağıdaki Fibonacci Yinelemesi’ne uyar: 338| Başlangıç durumları F(0) = 1 ve F(1) = 1 ile verilmiştir. Bunun anlamı, altın oran olarak eşittir (Daha kesin doğrulukla, iken F(h) yaklaşık ) Önerme 9.1’in kanıtında olduğu gibi, Bu nedenle, AVL Ağaç’ları, Kırmızı-Siyah Ağaç’lardan daha az yüksekliğe sahiptir. ekle(x) ve sil(x) işlemleri sırasında, yükseklik dengelemeyi şöyle sağlayabilirsiniz: Köke kadar yukarı yürürken rastladığınız her u düğümü için, u’nun sol ve sağ altağaçları arasındaki yükseklik farkı 2’den büyük ise, yeniden dengeleyin. Bkz.Şekil 9.10. | 339 Kırmızı-Siyah Ağaç’ların Andersson ve Sedgewick varyasyonları ile AVL Ağacı, bu bölümde tanımladığımız Kırmızı-Siyah Ağaç yapısını uygulamaktan daha kolaydır. Ne yazık ki, bunların hiçbiri, yeniden dengelemenin güncelleme başına O (1) zamanda çalışacağını garanti edemez. Özellikle, bu yapılar için Teorem 9.2’nin hiçbir benzeri yoktur. 340| Alıştırma 9.1. Şekil 9.11’de gösterilen Kırmızı-Siyah Ağacı’na karşılık gelen 2-4 Ağacı’nı gösterin. Alıştırma 9.2. Şekil 9.11’de gösterilen Kırmızı-Siyah Ağacı üzerine 13, sonra 3,5 ve sonra 3,3 değerlerini eklemeyi gösterin. Alıştırma 9.3. Şekil 9.11’de gösterilen Kırmızı-Siyah Ağacı’nın üzerinden 11, sonra 9 ve sonra 5 değerlerini silmeyi gösterin. Alıştırma 9.4. Oldukça büyük n değerleri için, 2log n – O(1) yüksekliğinde, n düğümlü Kırmızı-Siyah Ağaç’ların bulunduğunu gösterin. Alıştırma 9.5. pushBlack(u) ve pullBlack(u) işlemlerini düşünün. Bu işlemler Kırmızı-Siyah Ağacı’nın simule ettiği temel bir 2-4 ağacı üzerinde neler yapar? | 341 Alıştırma 9.6. Oldukça büyük n değerleri için, 2log n – O(1) yüksekliğinde, n düğümlü Kırmızı-Siyah Ağaç’lara bizi götürecek olan bir dizi ekle(x) ve sil(x) işlemlerinin var olduğunu gösterin. Alıştırma 9.7. Kırmızı-Siyah Ağaç uygulamasında sil(x) yöntemi neden u.parent = w.parent atamasını gerçekleştirir? Zaten bunun splice(w) çağrısı tarafından yapılması gerekmiyor muydu? Alıştırma 9.8. 2-4 Ağacı olan T’nin, nl yaprağı ve ni iç düğümü olduğunu düşünün. 1. nl cinsinden bir fonksiyon olarak, ni minimum değeri nedir? 2. nl cinsinden bir fonksiyon olarak, ni maksimum değeri nedir? 3. T kırmızı-siyah ağacını temsil eden bir T’ ağacı kaç tane kırmızı düğüme sahiptir? Alıştırma 9.9. Varsayın ki, n düğümlü ve en çok 2log n – 2 yüksekliğe sahip bir İkili Arama Ağacı verilmiştir. Siyah-yükseklik ve komşu-olmayan-kırmızı-kenar özelliklerini sağlayacak şekilde, ağacın düğümlerini kırmızı ve siyah olarak her zaman renklendirmek mümkün müdür? Eğer öyleyse, sola-dayanım özelliğini karşılayacak şekilde de yapılabilir mi? Alıştırma 9.10. Varsayın ki, T1 ve T2 aynı, h, siyah yüksekliğine sahip iki Kırmızı-Siyah Ağacı olsun, ve T1 üzerinde depolanan en büyük anahtar değer, T2 üzerinde depolanan en küçük anahtar de- 342| ğerden daha küçük olsun. T1 ve T2’yi tek bir kırmızı-siyah ağaç halinde O(h) zamanda nasıl birleştireceğinizi gösterin. Alıştırma 9.11. Alıştırma 9.10 için hazırladığınız çözümü, farklı siyah yüksekliğe, h1 h2, sahip iki Kırmızı-Siyah Ağaç için tekrar düşünün. Çalışma zamanı O(max(h1, h2)) olmalıdır. Alıştırma 9.12. ekle(x) işlemi sırasında bir AVL Ağacı en fazla bir kere yeniden dengeleme işlemi (en fazla iki döndürüş içeren, bkz.Şekil 9.10) gerçekleştirmelidir. AVL Ağacı’na bir örnek verin ve bu ağaç üzerinde çalışan sil(x) yöntemi, yeniden dengeleme işlemini log n kere çalıştırsın. Alıştırma 9.13. AVL Ağaç’larını yukarıda tanımlandığı gibi gerçekleştiren bir AVLAğacı sınıfını uygulayın. Performansını KırmızıSiyah Ağacı’nın bul(x) performansı ile karşılaştırın. Hangi uygulama işlemini daha hızlı çalıştırır? Alıştırma 9.14. Sekme Listesi Sıralı Küme, Günah Keçisi Ağacı, Treap, ve Kırmızı-Siyah Ağacı’nın Sıralı Küme uygulamaları için bul(x), ekle(x), sil(x) işlemlerinin performansını göreceli olarak karşılaştıran bir dizi deney tasarlayın ve gerçekleştirin. Verilerin rasgele olduğu, halihazırda sıralı olduğu, rasgele sırada silindiği, sıralı sırada silindiği, vb. birden fazla test senaryosunu dahil ettiğinizden emin olun. | 343 344| Bölüm 10 Yığınlar Bu bölümde, son derece yararlı bir veri yapısı olan Öncelik Kuyruğu’nun iki uygulamasını tanıtacağız. Bu yapıların her ikisi de, İkili Ağaç’ın "düzensiz küme" anlamına gelen, yığın adında özel bir türüdür. İkili Arama Ağacı, yığına kıyasla son derece düzenli bir kümedir. Yığın uygulamasının birincisi, mükemmel ikili ağacı simule eden bir dizi kullanır. Bu çok hızlı uygulama, yığın-sıralama adıyla bilinen en hızlı sıralama algoritmalarından birinin temelidir (bkz. Yığın-Sıralama Bölümü). İkinci uygulama, daha esnek ikili ağaçlara dayanmaktadır. İkinci bir öncelik kuyruğu olan h’in elemanlarını Öncelik Kuyruğu’nun içselleştirmesini sağlayan meld(h) işlemini destekler. İkili Yığın: Bir Örtülü İkili Ağaç Öncelik Kuyruğu’nun birinci uygulaması, dört yüz yıldan daha eski bir tekniğe dayanır. Eytzinger metotu, ağaç düğümlerini enine-ilk sırada düzenleyerek mükemmel İkili Ağacı bir dizi olarak göster- | 345 memize olanak tanır (bkz. İkili Ağaçta Sıralı-Düğüm Ziyaretleri Bölümü). Bu şekilde, kök, 0. konumda depolanır, kökün sol çocuğu 1. konumda depolanır, kökün sağ çocuğu 2. konumda, ve kökün sol çocuğunun sol çocuğu 3. konumda depolanır (bkz.Şekil 10.1). Yeterince büyük bir ağaca Eytzinger metotunu uygularsanız, bazı kalıplar ortaya çıkar. i’nci endeksteki düğümün sol alt çocuğu, left(i) = 2i + 1 konumunda yer alır, ve i’nci endeksteki düğümün sağ alt çocuğu, right(i) = 2i + 2 konumunda yer alır. i endeksindeki düğümün babası, parent(i) = (i – 1 )/2 konumunda yer alır. 346| İkili Yığın cı’nın elemanları, yığın-sıralı olan mükemmel bir İkili Ağa- dolaylı gösteriminde bu tekniği kullanır. Herhangi bir i en- deksinde depolanan değer babası olan parent(i) endeksinde depolanan değerden daha küçük değildir. Buna istisna, başlangıç noktası olan i = 0, kök değeridir. Buradan, Öncelik Kuyruğu'ndaki en küçük değerin, 0 konumunda (kökte) depolandığını çıkarabiliriz. n elemanlı İkili Yığın’ın elemanlarını a dizisinde depolayabiliriz: ekle(x) işleminin uygulaması oldukça basittir. Tüm dizi tabanlı yapılarda olduğu gibi, önce a’nın dolu olup olmadığını kontrol ederiz (a.length = n koşuluyla), ve eğer öyleyse, a büyültülür. Sonra, x, a[n] konumuna yerleştirilir, ve n, 1 artırılır. Bu noktada, geriye yapmamız gereken, yığın özelliğini korumayı sağlamaktır. x, babasından küçük olmayana kadar babası ile yer değiştirerek bunu yapabiliriz (bkz. Şekil 10.2). Yığından en küçük değeri silen, sil() işleminin uygulaması biraz daha zordur. Küçük değerin nerede olduğunu biliyoruz (kökte), ancak onu sildikten sonra yer değiştirmeliyiz, ve yığın özelliğini korumayı sağlamalıyız. | 347 Bunu yapmanın en kolay yolu, kökü a[n – 1] değeri ile yer değiştirmek, o değeri silmek, ve n’i 1 azaltmaktır. Ne yazık ki, kökteki yeni eleman şimdi muhtemelen, en küçük eleman değildir, bu nedenle aşağı yönde ilerlemeliyiz. Bu elemanı iki çocuğu ile karşılaştırarak bunu yaparız. Karşılaştırma sonucunda, eleman her üç elemanın en küçüğü ise, o zaman işlem tamamlanır. Aksi takdirde, iki çocuğunun en küçüğü ile bu elemanı yer değiştiririz ve devam ederiz. Diğer dizi-bazlı yapılarda olduğu gibi, yeniden_oluştur(u) çağrıları için harcanan çalışma zamanını önemsemeyeceğiz, çünkü bunlar Önerme 2.1’deki amortize argümanı kullanarak hesaplanabilir. ekle(x) ve sil(x) işlemlerinin çalışma zamanı (dolaylı olarak) İkili Ağacı’nın yüksekliğine bağlıdır. Neyse ki, bu bir mükemmel ikili ağaçtır, son seviye haricinde her seviyede olası maksimum düğüm sayısı depolanır. 348| Bu nedenle, ağacın yüksekliği h ise, en az 2h düğümü vardır. Başka bir deyişle, | 349 350| Bu denklemin her iki tarafının logaritması alındığı takdirde, Bu nedenle, ekle(x) ve sil(x) işleminin her ikisi de O(log n) zamanda çalışır. | 351 352| Özet Teorem 10.1. Aşağıdaki teorem İkili Yığın performansını özetlemektedir: İkili Yığın, Öncelik den_oluştur(u) Kuyruğu arayüzünü uygular. yeni- işlemi için yapılan çağrıların maliyeti önemsenme- diği takdirde, İkili Yığın işlem başına O(log n) zamanda çalışan ekle(x), sil(x) ve bul(x) işlemlerini destekler. Başlangıçta, İkili Yığın elemanları boş değer taşırken, m defa çağrılan ekle(x) den_oluştur(u) ve sil(x) işlemleri sırasında yapılan yeniçağrıları O(m) toplam zamanda çalışır. | 353 Karışık Yığın: Rasgele Karışık Yığın Bu bölümde, Öncelik Kuyruğu uygulamasının altında yatan temel yapı olarak yığın-sıralı bir İkili Ağacı’nın kullanıldığı Karışık Yığın’ı tanıtacağız. Ancak, İkili Yığın’ın altında yatan ağaç yapısı ta- mamen eleman sayısı ile tanımlandığı halde, Karışık Yığın’ın şekli üzerinde, ne olursa olsun, hiçbir kısıtlama yoktur. Karışık Yığın üzerinde ekle(x) ve sil() işlemleri, merge(h1, h2) işlemi cinsinden uygulanır. Bu işlem h1, h2 yığın düğümlerini alır, onları birleştirir, yığının kökü olan düğümü döndürür. Yığın kökü h1 kökenli altağacın tüm elemanlarını ve h2 kökenli altağacın tüm elemanlarını içerir. merge(h1, h2) işleminin iyi yanı, özyinelemeli olarak tanımlana- bilmesidir (bkz. Şekil 10.4). h1 veya h2’den biri nil ise, boş küme ile birleştiririz, bu nedenle, h2 veya h1’den birini, sırasıyla, döndürürüz. Aksi takdirde, varsayalım ki, h1.x eğer, h1.x h2.x h2.x olsun. Çünkü ise, h1 ve h2’nin rollerini değiştirebiliriz. O za- man biliyoruz ki, birleştirilmiş yığının kökü h1.x içerecektir ve h2’yi özyinelemeli olarak h1.left veya h1.right ile birleştirebiliriz. h2’yi birleştirmek için h1.left mi, h1.right mı sorusunun cevabına karar vermek için rasgelelik kullanılır ve yazı tura atılır. 354| Bir sonraki bölümde, merge(h1, h2) işleminin O(log n) beklenen zamanında çalıştığını göstereceğiz. h1 ve h2 içindeki toplam eleman sayısını n ile gösteriyoruz. merge(h1, h2) işleminden faydalandığımız takdirde, ekle(x) işle- mini uygulamak kolaydır. x değerini içeren yeni bir u düğümünü oluştururuz, ve u’yu yığının kökü ile birleştiririz: Bu işlem O(log n) = O(log(n+1)) beklenen zamanda çalışır. | 355 sil() işleminin uygulaması benzer şekilde kolaydır. Silmek istedi- ğimiz düğüm köktür, bu nedenle kökün iki çocuğunu birleştiririz ve sonucu kök yaparız. Yine bu, O(log n) beklenen zamanda çalışır. 356| Buna ek olarak, Karışık Yığın, O(log n) beklenen zamanda çalışan başka birçok işlemi de uygulayabilir. Bunlar arasında: sil(u) : u düğümünü (ve u.x anahtarını da) yığından siler. em(h) : Karışık Yığın, h, içindeki tüm elemanları bu yığına ekler, bu süreçte h yığınını boşaltır. merge(h1, h2) işlemi için sabit sayıda çağrı yaparak, bu işlemlerin her biri O(log n) beklenen toplam zamanda gerçekleştirilebilir. | 357 merge(h1, h2) Analizi merge(h1, h2) analizi, İkili Ağaç üzerinde rasgele yürüyüş analizi- ne dayanmaktadır. İkili Ağaç rasgele yürüyüşü ağacın kökünden başlar. Rasgele yürüyüşün her adımında yazı tura atılır ve sonucuna bakarak, bulunduğumuz düğümün sol veya sağ çocuğuna doğru ilerleriz. Ağacın sonuna geldiğimizde (bulunduğumuz düğüm nil olduğunda) yürüyüş sona erer. Aşağıdaki önerme önemlidir, çünkü İkili Ağacı’nın şekline tümden bağlı değildir. Önerme 10.1. n düğümlü bir İkili Ağacı’nda rasgele yürüyüşün beklenen uzunluğu en fazla log(n + 1) olur. Kanıt. n üzerinden tümevarım yöntemiyle kanıtlanacak. Taban durumunda, n = 0 iken, yürüyüş 0 = log n + 1 uzunluktadır. Sonucun negatif olmayan tüm tamsayılar n’ < n için doğru olduğunu varsayalım. n1, kökün sol altağacının büyüklüğünü göstersin, böylece n2 = n – n1 – 1 kökün sağ altağacın boyutudur. Kökten başlaya- rak, yürüyüş bir adım atar, sonra n1 veya n2 boyutlarında olan altağaç üzerinden devam eder. Tümevarım hipotezimiz ile yürüyüşün beklenen uzunluğu, 358| olur, Çünkü n1 ve n2, her ikisi n’den küçüktür. Log içbükey bir fonksiyon olduğu için, n1 = n2 = (n – 1) / 2 olduğunda, E[W] maksimize olur. Bu nedenle, rasgele yürüyüşün aldığı adımların beklenen sayısı, olur. Konu dışında kalsa da, bilgi teorisi konusunda az bilgi sahibi olan okuyucular için Önerme 10.1’in kanıtı entropi cinsinden de yapılabilir. Önerme 10.1 için Bilgi Teorik Kanıt. i 'nci dış düğümün derinliği di ile gösterilsin. n düğümlü ikili ağacın n + 1 dış düğüme sahip olduğunu hatırlayın. i’nci dış düğüme ulaşan rasgele yürüyüşün olasılığı tam olarak, lenen uzunluğu, olduğu için, rasgele yürüyüşün bek- | 359 ile verilir. Bu denklemin sağ tarafı n+1 eleman üzerinde bir olasılık dağılımının entropisi olarak kolaylıkla tanınabilir. n + 1 eleman için entropik değer, log(n+1) değerini aşmaz, bu kanıtı tamamlar. Rasgele yürüyüşler ile ilgili bu sonuçla birlikte, merge(h1, h2) işleminin O(log n) zamanda çalıştığını şimdi kolayca kanıtlayabiliriz. Önerme 10.2. n1 ve n2 düğüm içeren iki yığının kökleri, sırasıyla, h1 ve h2 ise, o zaman merge(h1, h2), n = n1 + n2 iken, O(log n) beklenen zamanda çalışır. Kanıt. h1, kökenli veya h2 kökenli yığınlar için merge algoritmasının her adımı, rasgele yürüyüşün bir adımını alır. Bu iki rasgele yürüyüşten herhangi biri ağacın sonuna geldiğinde (h1 = null, veya h2 = null) algoritma sona erer. Bu nedenle, merge algoritması tara- fından gerçekleştirilen adımların beklenen sayısı en fazla, olur. 360| Özet Aşağıdaki teorem Karışık Yığın’ın performansını özetlemektedir: Teorem 10.2. Karışık Yığın, Öncelik Kuyruğu arayüzünü uygular. Karışık Yığın işlem başına O(log n) beklenen zamanda çalışan ek- le(x), sil() işlemlerini destekler. | 361 Tartışma ve Alıştırmalar Mükemmel ikili ağacın bir dizi veya liste halinde dolaylı gösterimi ilk olarak Eytzinger [27] tarafından önerilmiştir. Kendisi, asil ailelerin soy ağaçlarını içeren kitaplarda bu gösterimi kullanmıştır. Bu bölümde anlatılan İkili Yığın veri yapısı, ilk olarak Williams [78] tarafından tanıtıldı. Bu bölümde tanıtılan Rasgele Karışık Yığın veri yapısı ilk olarak Gambin ve Malinowski [34] tarafından önerilmiştir. Diğer Karışık Yığın uygulamaları vardır: Sol-odaklı yığınlar [16, 48, Bileşik Nes- neler için Karma Kodları Bölümü], binom yığınları [75], Fibonacci yığınları [30], eşleştirme yığınları [29], ve çarpık yığınlar [72]; ancak hiçbiri Karışık Yığın yapısı kadar basit değildir. Yukarıdaki yapıların bazıları, decreaseKey(u, y) işlemini destekler. Bu işlem, u düğümünde depolanan değeri y’e düşürür (y ≤ x önkoşuldur). Önceki yapıların çoğu, u düğümünü silerek, ve y’i ekleyerek, bu işlemi O(log n) zamanda destekleyebilir. Bununla birlikte, bu yapıların bir kısmı, decreaseKey(u, y) işlemini daha verimli olarak uygulayabilir. Özellikle, decreaseKey(u, y), Fibonacci yığınları için O(1) amortize zaman alır. Eşleştirme yığınlarının [25] özel bir versiyonu için O(log log n) amortize zaman alır. Bu daha verimli olan decreaseKey(u, y) işlemi, Dijkstra'nın en kısa yol algoritması [30] dahil olmak üzere, birkaç grafik algoritmasını hızlandıran uygulamalarda kullanılır. 362| Alıştırma 10.1. Şekil 10.2 sonunda gösterilen İkili Ağacı’na, 7 ve daha sonra 3 değerlerinin eklenmesini gösterin. Alıştırma 10.2. Şekil 10.2 sonunda gösterilen İkili Ağacı’ndan, sonraki iki değerin (6 ve 8) silinmesini gösterin. Alıştırma 10.3. İkili Ağacı’nda depolanan a[i] değerini silen sil(i) işlemini uygulayın. Bu işlem O(log n) zamanda çalışmalıdır. Ardından, bu işlemin neden muhtemelen yararlı olmadığını açıklayın. Alıştırma 10.4. İkili Ağacı’nın bir genellemesi olan d-Ağacı’nda, her iç düğümün d çocuğu vardır. Mükemmel d-Ağaç’larını, Eytzinger yöntemini kullanarak, diziler yardımıyla göstermek mümkündür. Verilen bir i endeksi için, i’nin babası ve i’nin d çocuğunun her birinin endeksini belirleyen denklemleri hesaplayın. Alıştırma 10.5. Alıştırma 10.4’te öğrendiklerinizi kullanarak, İkili Yığın’ın d-li D-li Yığın genelleştirmesi olan D-li Yığını tasarlayın ve uygulayın. üzerindeki işlemlerin çalışma zamanlarını analiz edin, ve sizin yazdığınız D-li Yığın uygulamasının performansını, bu bölümde verilen İkili Yığın uygulamasının performansı ile karşılaştırın. Alıştırma 10.6. Şekil 10.4’te gösterilen, h1 Karışık Yığını’na, 17 ve sonra 82 değerinin eklenmesini gösterin. Rasgele biti örneklemek için, gerekirse madeni para kullanın. | 363 Alıştırma 10.7. Şekil 10.4’te gösterilen, h1 Karışık Yığını’ndan, sonraki iki değerin (4 ve 8) silinmesini gösterin. Rasgele biti örneklemek için, gerekirse madeni para kullanın. Alıştırma 10.8. Karışık Yığın’dan, u düğümünü silen sil(u) yöntemini uygulayın. Bu yöntem O(log n) beklenen zamanda çalışmalıdır. Alıştırma 10.9. İkili Yığın veya Karışık Yığın içinde depolanan, en küçük ikinci değeri sabit zamanda nasıl bulacağınızı gösterin. Alıştırma 10.10. İkili Yığın veya Karışık Yığın içinde depolanan en küçük k’nci değeri O(k log k) zamanda nasıl bulacağınızı gösterin (İpucu: İkinci bir yığının kullanılması yardımcı olacaktır). Alıştırma 10.11. Toplam uzunluğu n olan k adet sıralı liste verilsin. Bir yığın kullanarak, bunları tek bir sıralı liste halinde O(n log k) zamanda nasıl birleştireceğinizi gösterin (İpucu: Öğretici olması açısından, başlangıçta k = 2 olsun). 364| | 365 Bölüm 11 Sıralama Algoritmaları Bu bölüm, n elemanlı bir kümenin sıralaması ile ilgili algoritmaları tanıtıyor. Veri yapıları üzerine bir kitapta, bu konunun dahil edilmesi için birçok iyi neden vardır. En belirgin nedeni, bu sıralama algoritmalarının ikisinin (hızlı-sıralama ve yığın-sıralama), daha önce incelediğimiz veri yapılarının ikisi ile yakından ilişkili olmasıdır (sırasıyla, rasgele ikili arama ağaçları ve yığınlar). Bu bölümün birinci kısmında, yalnızca karşılaştırmalara dayanan sıralama algoritmalarını tartışacağız ve O(n log n) zamanda çalışan üç algoritmayı tanıtacağız. Anlaşılan, her üç algoritma da asimptotik olarak en iyidir; sadece karşılaştırmaları kullanan hiçbir algoritma, en kötü durumda veya ortalama olarak n log n karşılaştırmadan daha azını gerçekleştirmemiştir. Devam etmeden önce, unutmayın ki, önceki bölümlerde tanıtılan Sıralı Küme veya Öncelik Kuyruğu uygulamalarının herhangi biri, O(n log n) zamanda çalışan bir sıralama algoritmasını elde etmek için kullanılabilir. Örneğin, İkili Yığın veya Karışık Yığın üzerinde n ekle(x) işlemini ve bunu izleyen n sil() işlemini gerçekleştirerek n elemanı sıralayabiliriz. Alternatif olarak, İkili Arama Ağacı veri 366| yapılarının herhangi biri üzerinde, n ekle(x) işlemini çalıştırabilir ve sonra elemanları sıralı düzende elde etmek için içsel-sıra gezintisi (Alıştırma 6.8) gerçekleştirebiliriz. Ancak, her iki durumda da, tam olarak kullanılmayan bir yapıyı oluşturmak için bir sürü zahmete katlanılmaktadır. Bu nedenle sıralama, mümkün olan en hızlı, basit ve alan-verimli direkt yöntemler geliştirmeye değer önemli bir problemdir. Bu bölümün ikinci kısmı, karşılaştırmaların yanı sıra başka işlemlere yer verirsek, ne olacağını önceden tahmin edemeyeceğimizi gösteriyor. Gerçekten, {0,..,nc – 1} aralığındaki n tamsayıyı, dizi endekslemesini kullanarak, O(cn) zamanda sıralamak mümkündür. | 367 Karşılaştırmaya-Dayalı Sıralamalar Bu bölümde, üç sıralama algoritmasını tanıtacağız: birleştirereksıralama, hızlı-sıralama ve yığın-sıralama. Bu algoritmaların her biri girdi olarak a dizisini alır ve a’nın elemanlarını artan sırada O(n log n) (beklenen) zamanda sıralar. Bu algoritmaların hepsi karşılaştırmaya-dayalıdır. İkinci argümanları, c, compare(a, b) yöntemini uygulayan bir Karşılaştırıcı’dır. Bu algoritmalar hangi tür veriyi sıraladığını önemsemez; veri üzerinde yaptıkları tek işlem compare(a, b) yöntemini kullanarak yaptıkları karşılaştırmalardır. SKüme Arayüzü-Sıralı Kümeler Bölümü’nden hatırlamalısınız ki, a b ise compare(a, b) negatif bir değer döndürür, a tif bir değer döndürür, ve a = b ise sıfır döndürür. b için pozi- 368| Birleştirerek-Sıralama Birleştirerek-sıralama algoritması özyinelemeli böl ve yönet tekniğine klasik bir örnektir: a uzunluğu en fazla 1 ise, a zaten sıralanmıştır, bu yüzden hiçbir şey yapmayız. Aksi takdirde, a dizisini iki parçaya böleriz, a0 = a[0],...,a[n/2 – 1], ve a1 = a[n/2],..., a[n – 1]. Özyinelemeli olarak a0 ve a1 dizilerini sıralarız, ve sonra (şimdi sıralanmış bulunan) a0 ve a1 dizilerini tam sıralı bir a dizisini elde etmek için birleştiririz. Şekil 11.1 bir örneği göstermektedir. İki sıralı diziyi, a0 ve a1, birleştirmek, sıralamaya göre oldukça kolaydır. Her seferinde elemanlardan birini a’ya ekleriz. a0 veya a1 boşsa, o zaman diğer (boş olmayan) dizideki, sonra gelen ele- manları ekleriz. Aksi takdirde, a0 içindeki sonraki elemanın ve a1 içindeki sonraki elemanın en küçüğünü alır ve bunu a dizisine ekleriz: | 369 Fark edebilirsiniz ki, merge(a0, a1, a, c) algoritması a0 veya a1 dizilerindeki elemanları tüketmeden önce en fazla n – 1 karşılaştırma gerçekleştirir. 370| Birleştirerek-sıralama için gerekli çalışma zamanını anlamak için en kolay yol, onu bir özyineleme ağacı olarak düşünmektir. Şimdilik, n’in ikinin kuvveti olduğunu varsayın, öyle ki, log n bir tamsayı iken, n = 2log n olsun. Şekil 11.2’e bakın. Birleştirerek-sıralama, elemanın sıralanması problemini, her biri n/2 elemanı sıralayan n iki altproblem haline dönüştürür. Bu iki altproblem, yine daha sonra iki problem haline dönüşür, her biri n/4 elemandan oluşan dört altproblem elde edilir. Bu dört altproblem, her biri n/8 elemandan oluşan sekiz altproblem haline dönüşür, vb. Bu sürecin sonunda, altproblem, her birinin boyutu 1 olan n probleme dönüştürülür. n/2 n/2 i boyutundaki her altproblem için, birleştirmek ve veri kopya- lamak için harcanan zaman O(n/2i) olur. n/2i boyutunda 2 i altproblem olduğu için 2i boyutunda problemlerin üzerinde ça- lışmak için harcanan toplam zaman, özyinelemeli çağrılar önemsenmediği takdirde, | 371 olur. Böylece, birleştirerek-sıralama için harcanan toplam zaman, olarak hesaplanır. Aşağıdaki teoremin kanıtı, az önceki analize dayanır, ancak n, 2’nin kuvveti değil iken, biraz daha dikkatli olunmak zorundayız. Teorem 11.1. mergeSort(a, c) algoritması O(n log n) zamanda çalışır ve en çok n log n karşılaştırma gerçekleştirir. Kanıt. Kanıt n üzerine tümevarım yöntemiyle yapılacak. Başlangıç durumu, n = 1, önemsizdir. Uzunluğu 0, veya 1 olan bir dizi ile başlandığında, algoritma herhangi bir karşılaştırma yapmadan sadece diziyi döndürür. Toplam uzunluğu n olan iki sıralı listeyi birleştirmek, en fazla n – 1 karşılaştırmayı gerektirir. C(n) sayısı, mergeSort(a, c) tara- fından n uzunluğunda bir a dizisi üzerinde gerçekleştirilen karşılaştırmaların maksimum sayısı olsun. n çift ise, o zaman iki altproblem için tümevarım hipotezini uygulayarak, 372| elde ederiz. n tek olduğu zaman, durum biraz daha karmaşıktır. Bu durum için, doğrulanması kolay iki eşitsizlik kullanıyoruz: Her x ≥ 1 için, ve her x ≥ ½ için, (11.1) eşitsizliği log(x) + 1 = log(2x) gerçeğinden ileri geliyor. (11.2) eşitsizliği log fonksiyonunun içbükey özelliğe sahip olması gerçeğinden ileri geliyor. Elimizdeki bu araçlar ile, n tek iken, hesaplarız. | 373 Hızlı-Sıralama Hızlı-sıralama algoritması diğer bir klasik böl ve yönet algoritmasıdır. İki altproblemi çözdükten sonra birleştiren birleştirereksıralamanın aksine, hızlı-sıralama, çalışmasının hepsini veri üzerinde açık ve belirgin bir şekilde yapar. Hızlı-sıralamanın tanımlanması oldukça kolaydır: a içinden rasgele bir pivot elemanı, x, seçilir; x’den küçük elemanların oluşturduğu küme, x’e eşit elemanların oluşturduğu küme, ve x’den büyük elemanların oluşturduğu küme olmak üzere a üç parçaya bölünür, ve nihayet, özyinelemeli olarak birinci ve üçüncü kümeler sıralanır. Şekil 11.3’de bir örnek gösterilmiştir. 374| Tüm bunlar yerli yerinde yapılır, böylece, sıralanacak altdizilerin kopyalarını yapmak yerine, quickSort(a, i, n, c) yöntemi sadece a[i],…,a[i + n – 1] altdizisini sıralar. Başlangıçta, bu yöntem quickSort(a, 0, a.length, c) argümanları ile çağrılır. | 375 Hızlı-sıralama algoritmasının merkezinde, yerinde bölümleme algoritması vardır. Bu algoritma, herhangi bir ekstra alan kullanmadan, a elemanlarının yerlerini değiştirerek, p ve q endekslerini hesaplar; öyle ki, Kodda while döngüsü tarafından yapılan bu bölümleme, ilk ve son koşulu korumak şartıyla, p’nin yinelemeli artırılmasıyla ve q’nun azaltılmasıyla çalışır. Her adımda, j pozisyonundaki eleman ya öne taşınır, ya olduğu yerden sola kaydırılır, veya geriye taşınır. İlk iki durumda j artırılırken, son durumda j artırılmaz, çünkü j pozisyonundaki yeni eleman henüz işlenmemiştir. Hızlı-sıralama Bölüm 7’de anlatılan Rasgele İkili Arama Ağaç’ları ile çok yakından ilgilidir. Aslında, hızlı-sıralamanın girdisi n farklı 376| elemandan oluşuyorsa, hızlı-sıralamanın özyineleme ağacı bir Rasgele İkili Arama Ağacı’dır. Rasgele İkili Arama Ağacı’nı Bunu anlamak için, hatırlayın ki, oluşturacağımız zaman yaptığımız ilk şey, rasgele bir x elemanını seçmek ve bunu ağacın kökü yapmaktı. Bundan sonra, her bir eleman, sonunda x ile karşılaştırılmıştı, küçük elemanlar sol altağacın içine giderken, daha büyük elemanlar sağ altağacın içine depolanmıştı. Hızlı-sıralamada rasgele bir x elemanı seçeriz ve her şeyi hemen x ile karşılaştırırız, daha küçük elemanları dizinin başına koyarız, ve daha büyük elemanları dizinin sonuna koyarız. Daha sonra hızlısıralama özyinelemeli olarak, dizinin başlangıcını ve dizinin sonunu sıralarken, Rasgele İkili Arama Ağacı özyinelemeli olarak kökün sol altağacına daha küçük elemanları ve kökün sağ altağacına daha büyük elemanları ekler. Rasgele İkili Arama Ağaç’ları ve hızlı-sıralama arasındaki yukarı- daki benzeşmeler, Önerme 7.1’i hızlı-sıralama ile ilgili olarak şöyle tercüme eder: Önerme 11.1. 0,…,n – 1 tamsayılarını içeren bir diziyi sıralaması için hızlı-sıralamayı çağırdığınızda, i elemanını pivot eleman ile karşılaştırmak, en fazla Hi+1 + Hn-i beklenen sayıda gerçekleşir. Özetle, harmonik sayılar, bize hızlı-sıralamanın çalışma zamanı ile ilgili aşağıdaki teoremi verir: | 377 Teorem 11.2. Hızlı-sıralama n farklı elemanı içeren bir diziyi sıralamak için çağrıldığında, gerçekleştirilen karşılaştırmalar en fazla 2n ln n + O(n) beklenen sayıda olur. Kanıt. n farklı eleman sıralanırken, hızlı-sıralama tarafından gerçekleştirilen karşılaştırmaların sayısı T olsun. Önerme 11.1 ve beklentinin doğrusallık özelliği kullanılarak: Teorem 11.3 sıralanan tüm elemanların birbirinden farklı olduğu durumu anlatıyor. Girdi, a, dizisi, yinelenen elemanları içeriyorsa, hızlı-sıralamanın beklenen çalışma zamanı daha kötü değildir, ve hatta daha da iyi olabilir; ne zaman yinelenen bir eleman, x, pivot olarak seçilse, x’in tüm yinelemeleri biraraya gruplanır, ve her iki altproblemin hiçbirinde de yer almazlar. Teorem 11.3. quickSort(a, c) işlemi O(n log n) beklenen zamanda çalışır, ve gerçekleştirdiği karşılaştırmalar en fazla 2n ln n + O(n) beklenen sayıda olur. 378| | 379 Yığın-Sıralama Yığın-sıralama algoritması diğer bir yerinde-sıralama algoritmasıdır. Yığın-sıralama Bölüm 10’da tartışılan ikili yığınları kullanır. Hatırlayın ki, İkili Yığın veri yapısı tek bir dizi kullanarak yığını göstermektedir. Yığın-sıralama algoritması girdi, a, dizisini bir yığına dönüştürür ve daha sonra ard arda minimum değeri çıkarır. Özellikle, bir yığın, a, dizisi içindeki n elemanı en küçük değer kökte, a[0], depolanmak üzere, a[0], …,a[n – 1] konumlarında depolar. a, İkili Yığın’a dönüştürüldükten sonra, yığın sıralama algoritması tekrar tekrar a[0] ile a[n – 1]’in yerlerini değiştirerek, n’i 1 azaltır, ve trickledown(0) çağrılır. Böylece- a[0],...,a[n – 2], bir kere daha geçerli bir yığın olacaktır. Bu süreç sona erdiğinde (çünkü, n = 0), a elemanları azalan sırada depolanmış olur, a sıralamasını tersine çevirerek sıralamanın son halini elde ederiz. Şekil 11.4 heapSort(a, c) çalıştırmasına bir örnek gösteriyor. Yığın-sıralamanın anahtar altyordamı, sıralı olmayan bir a dizisini yığına dönüştüren kurucu programdır. İkili Yığın’ın ekle(x) işlemini 380| defalarca çağırarak bunu O(n log n) zamanda yapmak kolay olurdu, ancak aşağıdan-yukarıya algoritma kullanarak daha iyisini yapabiliriz. Hatırlayın ki, bir İkili Yığın içinde a[i]’nin çocukları a[2i + 1] ve a[2i + 2] konumlarında depolanır. Bunun anlamı, elemanlarının çocuğu yoktur. Diğer bir deyiş- le, her biri boyutu 1 olan bir altyığındır. Şimdi, geriye doğru çalışırsak, için trickleDown(i) çağrısını yaparız. Bu işe yarar, çünkü trickleDown(i) çağrısı yapıldığı zaman a[i]’nin her iki çocuğu, bir altyığının köküdür, böylece trickleDown(i) çağrısı a[i]’yi kendi altyığınının kökü yapar. Bu aşağıdan-yukarıya strateji ile ilgili ilginç olan, n defa ekle(x) çağırmaktan daha verimli olmasıdır. Bunu anlamak için, n/2 eleman için, hiçbir şey yapmayız, n/4 eleman için a[i] kökenli ve yüksekliği bir olan bir altyığın üzerine trickleDown(i) çağrısı yaparız, n/8 eleman için yüksekliği iki olan bir altyığın üzerine trickleDown(i) çağrısı yaparız, vb. trickleDown(i) tarafından yapı- lan iş, a[i] kökenli bir altyığının yüksekliği ile orantılı olduğu için, toplam yapılan iş en fazla, | 381 olur. Sondan ikinci eşitliği, toplamının, ilk defa yazı gelene kadar atılan yazı-turanın beklenen sayısına eşit olduğunu hatırlayarak, ve Önerme 4.2’yi uygulayarak oluşturduk. Aşağıdaki teorem heapSort(a, c) performansını açıklıyor. Teorem 11.4. heapSort(a, c) işlemi O(n log n) zamanda çalışır ve en fazla 2n log n + O(n) karşılaştırma gerçekleştirir. Kanıt. Algoritma üç adımda çalışır: (1) a dizisinin bir yığın içine dönüştürülmesi (2) a içinden ard arda minimum elemanın çıkarılması, (3) a elemanlarının tersine çevrilmesi. Adım 1’in çalışması için, O(n) zaman gerektiği ve O(n) karşılaştırma gerçekleştirdiğini az önce tartışmıştık. Adım 3, O(n) zaman alır ve hiçbir karşılaştırma yapmaz. Adım 2, trickleDown(0) için n çağrı gerçekleştirir. i 'nci böyle bir çağrı n – i boyutunda bir yığın üzerinde çalışır ve en fazla 2log(n – i) karşılaştırma gerçekleştirir. i üzerinden bunları toplayarak, 382| elde ederiz. Üç adımın her birinde yapılan karşılaştırmaların sayısını toplayarak kanıt tamamlanır. | 383 Karşılaştırmaya Dayalı Sıralama için Alt-Sınır Gördüğümüz karşılaştırmaya-dayalı sıralama algoritmalarının her biri O(n log n) zamanda çalışmaktadır. Şu andan itibaren, daha hızlı algoritmaların var olup olmadığına dikkatimize vereceğiz. Bu soruya verilecek en kısa cevap hayır olacaktır. a elemanları üzerinde sadece karşılaştırmaya izin veriliyorsa, o zaman hiçbir algoritma n log n karşılaştırmadana daha azını yapmaktan kaçınamaz. Bunu kanıtlamak zor değildir, ancak biraz hayal gücü gerektirir. Kanıt eninde sonunda, gerçeğinden yola çıkar (Bu gerçeğin kanıtlanması Alıştırma 11.1’e bırakılmıştır). Belirli bir sabit n değeri için dikkatimizi ilk olarak birleştirereksıralama ve yığın-sıralama gibi deterministik algoritmalara odaklayacağız. Birbirinden farklı n elemanı sıralamak için böyle bir algo- 384| ritmanın kullanıldığını varsayın. Alt sınırı kanıtlama yolunda anahtar rol oynayan gözlem şudur ki, sabit bir n değeri ile başlayan deterministik bir algoritma için, karşılaştırılan ilk eleman çifti her zaman aynıdır. Örneğin, heapSort(a, c) için n çift ise, trickleDown(i) için yapılan ilk çağrı i = n/2 – 1 için yapılır, ve ilk karşılaştırma a[n/2 – 1] ve a[n – 1] elemanları arasında gerçekleşir. Tüm girdi elemanları birbirinden farklı olduğu için, bu ilk karşılaştırmanın sadece iki olası sonucu vardır. Algoritma tarafından yapılan ikinci karşılaştırma, birinci karşılaştırmanın sonucuna bağlı olabilir. Üçüncü karşılaştırma, böylece ilk ikisinin sonuçlarına bağlı olabilir, vb. Bu nedenle, herhangi bir deterministik, karşılaştırmaya-dayalı sıralama algoritması köklü bir ikili karşılaştırma ağacı olarak görülebilir. Bu ağacın her, u iç düğümü, u.i ve u.j endeks çifti ile etiketlenmiştir. a[u.i] < a[u.j] ise algoritma sol alt ağaca doğru ilerler, aksi takdirde sağ alt ağaca doğru devam eder. Bu ağacın her, w yaprağı, 0,…,n – 1 aralığındaki bir w.p[0],…,w.p[n – 1] permütasyonu ile etiketlenmiştir. Bu permütasyon, karşılaştırma ağacı bu yaprağa ulaşırsa, a’yı sıralamak için gereklidir. Yani, Şekil 11.5, boyutu, n = 3 olan, bir dizi için karşılaştırma ağacına bir örnek göstermektedir. | 385 Karşılaştırma ağacı, bir sıralama algoritması hakkında her şeyi anlatır. Herhangi bir a girdi dizisi için, birbirinden farklı, n, elemanı hangi sırada karşılaştıracağımızı, ve a’yı sıralarken nasıl düzenleyeceğimizi belirtir. Sonuç olarak, karşılaştırma ağacı en az n! yapraktan oluşmalıdır; eğer değilse, aynı yaprağa giden iki farklı permütasyon bulunmaktadır; bu nedenle algoritma bu permütasyonların en azından birini doğru olarak sıralamayacaktır. Örneğin, Şekil 11.6’deki karşılaştırma ağacı, 4 3! = 6 yaprağa sahiptir. Bu ağacı incelersek, görüyoruz ki, iki girdi dizisi 3, 1, 2 ve 3, 2, 1 en sağdaki yaprağa götürür. 3, 1, 2 girdisi için doğru çıktı üretilir, a[1] = 1, a[2] = 2, a[0] = 3. Ancak, 3, 2, 1 girdisi için, hatalı çıktı üretir a[1] = 2, a[2] = 1, a[0] = 3. Bu tartışma, karşılaştırmaya dayalı algoritmalar için birincil alt sınırı açıklıyor. Teorem 11.5. Herhangi bir deterministik, karşılaştırmaya dayalı, A, sıralama algoritması ve herhangi bir n ≥ 1 tamsayısı için, n uzunluğunda öyle bir, a, girdi dizisi vardır ki, A, a dizisini sıralarken en az log(n!)= n logn – O(n) karşılaştırma gerçekleştirir. 386| Kanıt. Önceki tartışmayla, A tarafından tanımlanan karşılaştırma ağacı en az n! yaprak içermelidir. Kolay bir tümevarım kanıtı gösterir ki, k yapraklı herhangi bir ikili ağaç en az log k yüksekliğe sahiptir. Bu nedenle, A’nın karşılaştırma ağacında, derinliği en az log(n!) olan bir w yaprağı ve bu yaprağa giden bir girdi, a dizisi bulunmaktadır. Girdi, a, dizisi üzerinde A, en az log(n!) karşılaştırma gerçekleştirir. Teorem 11.5 birleştirerek-sıralama ve yığın-sıralama gibi deterministik algoritmalar ile ilgilenir, ancak hızlı-sıralama gibi randomize algoritmalar hakkında hiçbir şey söylemez. Acaba bir randomize algoritma, karşılaştırma sayısı için var olan log(n!) alt sınırını aşabilir mi? Cevap, yine hayır. Bunu kanıtlamanın yolu, yine, randomize algoritmalar hakkında farklı düşünmektir. Aşağıdaki tartışmada varsayalım ki, karar ağaçlarımız şu yolla “düzeltilmiştir”: Girdi, a dizisi tarafından ulaşılamayan herhangi bir düğüm silinir. Bu temizliğin anlamı ağaç tam olarak n! yaprağa sahip olur. n! yaprağı vardır çünkü aksi takdirde, sıralama doğru olmazdı. En fazla n! yaprağı vardır, çünkü n farklı elemanın olası her n! permütasyonu, karar ağacında kökten başlayarak yaprağa giden tam olarak bir yolu izler. İki girdi kabul eden deterministik bir R, randomize sıralama algoritması düşünebiliriz: Sıralanması gereken bir girdi a dizisi, ve [0, 1] aralığında rasgele reel sayılardan oluşan uzun bir dizi b = b1, b2, b3,…,bm. Rasgele sayılar, algoritma için randomizasyon | 387 sağlıyor. Algoritmanın, yazı tura atması, veya rasgele bir seçim yapması gerektiğinde, bunu b içinden bazı elemanı kullanarak yapar. Örneğin, hızlı-sıralamada ilk pivot endeksini hesaplamak için, algoritma formülünü kullanabilir. Şimdi fark edebilirsiniz ki, eğer b’yi, bazı özel bir dizilimine sabitleyebilirsek, R deterministik sıralama algoritması haline gelir ve ilgili karşılaştırma ağacı , olur. Ardından, fark edebilirsiniz ki {1,…,n} aralığında rasgele bir a permütasyonu seçersek, bu, ’nin n! yaprağı için- den, rasgele bir, w, yaprağını seçmekle eşdeğerdir. Alıştırma 11.13, k yapraklı herhangi bir ikili ağaçtan rasgele bir yaprak seçersek, o yaprağın beklenen derinliğinin en az log k olduğunu kanıtlamanızı istiyor. Bu nedenle, {1,…,n} aralığında rasgele bir permütasyon içeren bir girdi dizisi verildiğinde, (deterministik) algoritma, tarafından yapılan karşılaştırmaların beklenen sayı- sı en az log(n!) olarak hesaplanır. Son olarak, not etmelisiniz ki, ’nin her seçimi için bu doğrudur, bu nedenle R için bile geçerlidir. Böylece, randomize algoritmalar için alt sınır kanıtı tamamlanır. Teorem 11.6. Herhangi bir (deterministik veya randomize) karşılaştırmaya-dayalı sıralama algoritması, A, herhangi bir tamsayı n ≥ 1 için, {1,…,n} aralığında rasgele bir permütasyonu sıralarken, en az log(n!) = n log n – O(n) beklenen sayıda karşılaştırma gerçekleştirir. 388| Sayma Sıralama ve Taban Sıralaması Bu bölümde karşılaştırmaya dayalı olmayan iki sıralama algoritmasını tanıtıyoruz. Bu algoritmalar küçük tamsayıları sıralamak için özelleştirilmiştir, ve a dizisindeki elemanların parçalarını bir diziye endeks olarak kullanarak, Teorem 11.5’in alt sınırından kurtulurlar. şeklinde bir ifade düşünün. Bu ifade sabit zamanda çalışır, ancak, a[i] değerine bağlı olarak değişen c.length kadar farklı olası sonu- cu vardır. Bunun anlamı, bu tür bir komut içeren bir algoritmanın çalışması ikili ağaç olarak modellenemez. Sonuç olarak, bu bölümdeki algoritmaların, karşılaştırmaya dayalı algoritmalardan daha hızlı sıralamalarına neden budur. | 389 Sayma Sıralaması Her biri 0,…,k – 1 aralığında n tamsayıdan oluşan bir girdi, a dizisinin olduğunu varsayalım. Sayma-sıralama algoritması, sayaçları depolayan, yardımcı bir c dizisini kullanarak, a’yı sıralar. a’nın sıralı çıktısını da yardımcı bir b dizisi tutar. Sayma-sıralaması arkasındaki fikir basittir: Her i {0,…,k – 1} için, a içindeki i’nin yinelenme sayısını sayın ve bunu c[i]’de saklayın. Şimdi sıralama sonrasında, 0’ın yinelenme sayısını c[0], 1’in yinelenme sayısını c[1], 2’nin yinelenme sayısını c[2],…,k – 1’in yinelenme sayısını c[k – 1] tutacaktır. Bunu gerçekleştiren kod çok düzgündür, ve örnek çalıştırması Şekil 11.7’de gösterilmiştir: Bu koddaki birinci for döngüsü, her c[i] sayacını, a içindeki i yinelemelerini sayarak belirler. a değerlerini endeks olarak kullanarak, bu sayaçların tümü O(n) zamanda tek bir for döngüsü içinde hesaplanabilir. 390| Bu noktada, çıktı dizisi b’yi doldurmak için doğrudan c’yi kullanabiliriz. Ancak, a elemanlarının ilişkili verisi varsa, bu işe yaramayacaktır. Bu nedenle, b içine a elemanlarını kopyalamak için biraz fazladan çaba harcarız. O(k) zaman alan bir sonraki for döngüsü sayaçların toplamını he- saplar, böylece a içinde, i’den daha az, veya eşit olan elemanların sayısı c[i]’de saklanır. Özellikle, her i dizisi b için, {0,…,k – 1} için, çıktı | 391 olacaktır. Son olarak, algoritma, geri yönde tarayarak, elemanlarını sıralı bir şekilde çıktı b dizisine yerleştirir. Tararken, a[i] = j elemanı, b[c[j] – 1] konumuna yerleştirilir ve c[j] değeri 1 azaltılır. Teorem 11.7. countingSort(a, k) yöntemi, {0,…,k – 1} kümesinden n tamsayıyı içeren, a dizisini O(n + k) zamanda sıralayabilir. Sayma-sıralaması algoritmasının kararlı olmak gibi güzel bir özelliği vardır; eşit elemanların göreli sırasını korur. İki eleman a[i] ve a[j], aynı değere sahipse, ve i j ise, b içinde a[i], a[j]’den önce görünecektir. Bir sonraki bölümde bu yararlı olacaktır. 392| Taban-Sıralaması Sayma-sıralaması n dizi uzunluğu, dizinin maksimum değeri, k – 1’den çok daha küçük olmadığı zaman, bir tamsayı dizisini sırala- makta çok verimlidir. Şimdi tanıtacağımız taban-sıralaması algoritması, sayma-sıralamasının birkaç geçişini kullanıyor ve çok daha büyük bir maksimum değer aralığını sıralayabiliyor. Taban-sıralaması, sayma sıralamasının w/d geçişini kullanarak her geçişte d bit olmak üzere, w-bit tamsayıları sıralıyor. Daha kesin olarak, taban-sıralamasında tamsayılar önce en az önemli d bitine göre, daha sonra bir sonraki önemli d bitine göre, ve bu şekilde son seferde en önemli d bitine göre sıralanır. (Bu kodda, (a[i]>>d * p)&((1<<d) – 1) (p + 1)d – 1,…,pd ifadesi, a[i]’nin biti tarafından ikili gösterimi verilen tamsayıyı | 393 çıkarır). Bu algoritma adımlarının bir örneği Şekil 11.8’de gösterilmiştir. Bu dikkat çekici algoritma doğru sıralamaktadır, çünkü saymasıralaması kararlı bir sıralama algoritmasıdır. a’nın iki elemanı x<y ise, ve x, y’den en önemli r endeksinde farklılık gösteriyorsa, o zaman r/d geçişi sırasında x, y’den önce yerleştirilecektir ve daha sonraki geçişlerde, x ve y’nin göreli sırası değişmeyecektir. Taban-sıralaması, sayma-sıralamasının w/d geçişini çalıştırır. Her geçiş O(n + 2d) çalışma zamanı gerektirir. Taban-sıralamasının performansı aşağıdaki teorem ile verilmiştir. Teorem 11.8. Herhangi bir tamsayı d > 0 için, radixSort(a, k) yöntemi, n adet w-bit tamsayı içeren bir a dizisini O((w/d)(n+2d)) çalışma zamanında sıralar. 394| Bunun yerine, {0, nc – 1} aralığında dizinin elemanlarını düşünürsek, ve d = log n aldığımızda, Teorem 11.8’in aşağıdaki versiyonunu elde ederiz. Sonuç 11.1. radixSort(a, k) yöntemi {0, nc – 1} aralığında n tamsayı değeri içeren bir a dizisini O(cn) zamanda sıralar. | 395 Tartışma ve Alıştırmalar Sıralama, bilgisayar bilimlerinin temel bir algoritmik problemidir, ve uzun bir geçmişi vardır. Knuth [48] birleştirerek-sıralama algoritması için von Neumann’a (1945) başvuruyor. Hızlı-sıralama, Hoare [39] sayesindedir. Orijinal yığın-sıralama algoritması Williams [78]’a atfedilir, ancak burada yer alan versiyonun (yığın O(n) zaman içinde aşağıdan-yukarıya oluşturuluyorsa) kaynağı Floyd [28]’dur. Karşılaştırmaya dayalı sıralamada alt sınırlar çok iyi bilinmektedir. Aşağıda tabloda, karşılaştırmaya dayalı algoritmaların performansı özetleniyor: Bu karşılaştırmaya dayalı algoritmaların avantaj ve dezavantajları vardır. Birleştirerek-sıralama, en az sayıda karşılaştırma yapar ve randomizasyona dayanmaz. Ne yazık ki, birleştirme safhasında bir yardımcı dizi kullanır. Bu diziyi tahsis etmek pahalı olabilir ve bellek miktarı sınırlı ise potansiyel bir başarısızlık sebebidir. Hızlısıralama yerinde-işlem yapan bir algoritmadır ve yaptığı karşılaştırma sayısı açısından baştan ikincidir, ancak randomizedir, bu nedenle çalışma zamanı her zaman garanti edilmez. Yığın-sıralama en 396| fazla sayıda karşılaştırmayı yapar, ama yerinde ve deterministik işlem yapar. Bağlantılı-listeyi sıralarken birleştirerek-sıralama net olarak enöndedir. Bu durumda, yardımcı dizi gerekli değildir; sıralı iki bağlantılı-liste, işaretçi işlemleri ile çok kolayca tek bir bağlantılı liste halinde birleştirilebilir (bkz. Alıştırma 11.2). Bu bölümde tanıtılan sayma-sıralaması ve taban-sıralaması algoritmaları Seward sayesindedir [68, bkz.Dizi İki Başlı Kuyruk: Dizi Kullanan Hızlı İki Başlı Kuyruk Bölümü]. Ancak, tabansıralamasının değişik çeşitleri, 1920'lerden beri, delikli kart sıralama makinelerini kullanarak delikli kartları sıralamak için kullanılmaktadır. Bu makineler kartın belirli bir yerindeki bir deliğin varlığına (veya yokluğuna) dayalı olarak kart destesini iki yığın halinde sıralayabilirler. Farklı delik yerleri için bu işlemi tekrar etmek taban-sıralamasının bir uygulamasını verir. Son olarak, not ediniz ki, sayma-sıralama ve taban-sıralama, negatif olmayan tamsayıların yanı sıra, diğer sayı türlerini sıralamak için de kullanılabilir. Kolay değişiklikler yaparak {a,…,b} aralığındaki tamsayılar, sayma sıralama ile O(n + b – a) çalışma zamanında sıralanabilir. Benzer şekilde, taban-sıralama aynı aralıktaki tamsayıları O(n(logn(b – a)) çalışma zamanında sıralayabilir. Son olarak, bu algoritmaların her ikisi de, IEEE 754 kayan nokta formatında, kayan nokta sayılarını sıralamak için kullanılabilir. Bunun nedeni, IEEE formatı, iki kayan noktalı sayının değerini, sanki işaretli | 397 ikili gösteriminde birer tamsayı gibi karşılaştırmak için tasarlanmıştır. Alıştırma 11.1. 1,7,4,6,2,8,3,5 içeren bir girdi dizisi üzerinde birleştirme-sıralama ve yığın-sıralamanın çalışmasını gösterin. Aynı dizi üzerinde, hızlı-sıralamanın olası bir çalışmasına örnek gösterin. Alıştırma 11.2. Birleştirme-sıralama algoritmasının bir versiyonunu uygulayın. Bu versiyon, yardımcı bir dizi kullanmadan Çifte Bağlantılı Liste’yi sıralamalıdır (bkz. Alıştırma 3.13). Alıştırma 11.3. Bazı quickSort(a, i, n, c) uygulamaları, pivot olarak her zaman a[i] kullanır. n uzunluğunda öyle bir girdi dizisi örneği verin ki, bu girdiyle çalışan uygulama karşılaştırma ger- çekleştirsin. Alıştırma 11.4. Bazı quickSort(a, i, n, c) uygulamaları, pivot olarak her zaman a[i + n/2] kullanır. n uzunluğunda, öyle bir girdi dizisi örneği verin ki, bu girdiyle çalışan uygulama karşılaştır- ma gerçekleştirsin. Alıştırma 11.5. a[i],…,a[i + n – 1] değerlerine bakmadan, pivotu deterministik olarak seçen herhangi bir quickSort(a, i, n, c) uygulaması için, her zaman karşılaştırma gerçekleştiren, n uzunlu- ğunda bir girdi dizisinin var olduğunu gösterin. 398| Alıştırma 11.6. quickSort(a, i, n, c) uygulamasına bir argüman olarak geçirilen bir Karşılaştırıcı, c, tasarlayın. Hızlı-sıralama, bu argümanla çalıştırıldığında, karşılaştırma gerçekleştirmelidir. (İpucu: Karşılaştırıcının, karşılaştırılan değerlere gerçekten bakması gerekli değildir). Alıştırma 11.7. Hızlı sıralama tarafından yapılan karşılaştırmaların beklenen sayısının 2nHn – n + Hn olduğunu gösterin. Özellikle, Teorem 11.3’ün kanıtında verilen analizden daha dikkatli analiz edin. Alıştırma 11.8. Yığın-sıralamanın, en az 2n log n – O(n) karşılaştırma gerçekleştirmesine neden olan bir girdi dizisi tanımlayın. Cevabınızı doğrulayın. Alıştırma 11.9. Bu bölümde tanıtılan yığın-sıralama uygulaması, elemanlarını ters sırada sıralıyor, ve daha sonra diziyi tersine çeviriyor. Bu son adımdan kaçınmak için, girdi Karşılaştırıcı’sı, c’nin sonucunu olumsuzlayan, yeni bir Karşılaştırıcı tanımlanabilir. Bunun, neden iyi bir optimizasyon olmadığını açıklayın (İpucu: Diziyi tersine çevirmenin maliyeti ile, kaç adet olumsuzlama gerçekleştirilmesinin maliyetini kıyaslayın). Alıştırma 11.10. Şekil 11.6’deki karşılaştırma ağacı tarafından doğru sıralanmayan, bir başka 1, 2, 3 permütasyon çiftini bulun. Alıştırma 11.11. log n! = n log n – O(n) olduğunu kanıtlayın. | 399 Alıştırma 11.12. k yapraklı ikili ağacın yüksekliğinin en az log k olduğunu kanıtlayın. Alıştırma 11.13. k yapraklı ikili ağaçtan rasgele bir yaprak seçersek, bu yaprağın beklenen yüksekliğinin en az log k olduğunu kanıtlayın. Alıştırma 11.14. Bu bölümde tanıtılan radixSort(a, k) uygulaması girdi, a dizisi, sadece negatif olmayan tamsayıları içerdiği zaman çalışır. a, hem negatif ve hem de negatif olmayan tamsayıları içerdiğinde, uygulamanın düzgün çalışması için gerekli değişiklikleri yapın. 400| | 401 Bölüm 12 Grafikler Bu bölümde, grafiklerin iki gösterimini ve bu gösterimleri kullanan temel algoritmaları tanıtacağız. Matematiksel olarak, (yönlü) grafik bir G = (V, E) çiftidir. Burada, V, köşelerden oluşan bir küme, E, kenarlar adıyla belirtilen sıralı köşe çiftlerinden oluşan bir kümedir. (i, j) kenarının yönü i’den j’ye doğrudur; i, kenarın kaynağı, ve j, hedef olarak adlandırılır. v0,…,vk köşelerinden oluşan bir dizi, G üzerinde bir yoldur, öyle ki her i {1,…,k} için (vi-1, vi) kenarı E kümesinin elemanıdır. Eğer, buna ek olarak, (vk, v0) kenarı da E’nin elemanıysa v0,…,vk yolu bir döngüdür. Eğer tüm köşeleri benzersiz ve tekil ise, yol (veya döngü) basittir. Herhangi bir vi köşesinden, herhangi bir vj köşesine yol varsa, vj’nin vi’dan ulaşılabilir olduğunu söyleriz. Şekil 12.1 bir grafik örneğini göstermektedir. Birçok fenomeni modelleme yetenekleri nedeniyle, grafiklerin büyük sayıda uygulamaları vardır. Çok belirgin örnekler vardır. Bilgisayar ağları, köşeleri bilgisayarlar olan ve kenarları bu bilgisayarlar arasındaki (yönlü) iletişim bağlantıları olan grafikler halinde modellenebilir. Şehir sokakları grafik olarak modellenebilir, köşeler 402| kavşaklar ile temsil edilirken, kenarlar ardışık kavşakları birleştiren sokakları gösterir. Daha az belirgin örnekler, bir küme içindeki herhangi ikili ilişkileri grafikler ile modelleyebileceğimizi fark ettiğimizde ortaya çıkar. Örneğin, bir üniversite ortamında, bir ders programı çatışma grafiği oluşturulabilir, burada köşeler üniversitede açılan dersleri temsil ederken, hem sınıf i ve hem sınıf j’yi alan en az bir öğrenci varsa, (i, j) kenarı grafikte yer alır. Böylece, bir kenar, i sınıfı için düzen- lenecek bir sınavın, aynı saatte j sınıfı için düzenlenmeyeceğine işaret eder. Bu bölüm boyunca, G köşe sayısını göstermek için, n, ve G kenar sayısını göstermek için, m kullanacağız. Yani, ve . Ayrıca, V = {0,…,n – 1} olduğunu varsayacağız. V elemanları ile | 403 ilişkilendirmek istediğimiz başka bir veri, n uzunluğunda bir dizide depolanabilir. Grafikler üzerinde gerçekleştirilen bazı yaygın işlemler şunlardır: addEdge(i, j) removeEdge(i, j) : (i, j) hasEdge(i, j) outEdges(i) : (i, j) kenarını E’ye ekler. kenarını E’den siler. : Kenar (i, j) E olup olmadığını kontrol eder. : (i, j) E olan tüm j tamsayılarının bir Liste’sini döndürür. inEdges(i) : (j, i) E olan tüm j tamsayılarının bir Liste’sini döndürür. Bu işlemleri verimli uygulamanın çok zor olmadığını unutmayın. Örneğin, ilk üç işlem, Sırasız Küme kullanılarak doğrudan uygulanabilir, bu nedenle, Bölüm 5’te tartışılan karma tabloları kullanılarak, sabit beklenen zamanda çalışır. Son iki işlem, her bir köşe için, ona bitişik köşelerin bir listesini depolayarak, sabit zamanda uygulanabilir. Ancak, bu işlemler için, farklı grafik uygulamalarının, farklı performans gereksinimleri vardır ve ideal olarak en basit gerçekleştirimi uygulamanın tüm gereksinimini karşılayacak şekilde kullanmalıyız. Bu nedenle, grafik gösterimlerini iki geniş kategoride tartışıyoruz. 404| Bitişiklik Matrisi: Bir Grafiğin Matris ile Gösterimi Bitişiklik matrisi, n köşeli bir G = (V, E) grafiğini, elemanları boolean değerler alan bir n x n matrisi ile gösterir. Matris elemanı a[i][j], olarak tanımlanır. Şekil 12.1’deki grafik için bitişiklik matrisi, Şekil 12.2’de gösterilmiştir. Bu gösterimde, addEdge(i, j), removeEdge(i, j), ve hasEdge(i, j) işlemleri, a[i][j] elemanını sadece belirlemeyi veya okumayı içerir: | 405 Bu işlemler, işlem başına açıkça sabit zaman alır. Bitişiklik outEdges(i) a’nın matrisinin kötü performans sergilediği yerler, ve inEdges(i) işlemleridir. Bunları uygulamak için, karşılık gelen satır veya sütunundaki bütün n elemanlarını taramalıyız ve sırasıyla a[i][j] ve a[j][i]’nin true değer aldığı tüm j endekslerini toplamalıyız. 406| | 407 Bu işlemler, işlem başına açıkça O(n) çalışma zamanı alır. Bitişiklik matrisi gösteriminin başka bir dezavantajı büyük olmasıdır. n x n boolean matrisini depolaması nedeniyle en az n2 bit bellek gerektirir. Buradaki uygulama boolean değerlerden oluşan bir matris kullanıyor, bu nedenle, gerçekte n2 bayt büyüklüğünde belleği kullanıyor. w boolean değeri her bir bellek sözcüğünün içinde tutan daha dikkatli bir uygulama, alan kullanımını O(n2/w) bellek sözcüğüne kadar azaltabilir. Teorem 12.1. Bitişiklik Matrisi veri yapısı, Grafik arayüzünü uygular. Bitişiklik Matrisi aşağıdaki işlemleri destekler: İşlem başına sabit zamanda çalışan addEdge(i, j), removeEdge(i, j), hasEdge(i, j) İşlem başına O(n) zamanda outEdges(i). 2 Bitişiklik Matrisi O(n ) ve, alan kullanır. çalışan inEdges(i), 408| Yüksek bellek gereksinimlerine ve inEdges(i) ve outEdges(i) işlemlerinin kötü performansına rağmen, Bitişiklik Matrisi hala bazı uygulamalarda kullanışlı olabilir. Özellikle, G grafiği yoğunsa, yani kenar sayısı n2’ye yakınsa, o zaman n2 bellek kullanımı kabul edilebilir. Bitişiklik Matrisi veri yapısı, aynı zamanda yaygın olarak kullanıl- maktadır, çünkü G grafiğinin özelliklerini verimli hesaplamak için a matrisi üzerindeki cebirsel işlemleri kullanabilirsiniz. Bu konu algoritmalar dersi içeriğinde yer alabilir, ancak burada şöyle bir özelliğe dikkat çekeceğiz: a’nın girdilerini tamsayı olarak kabul edersek (true için 1, ve false için 0), ve matris çarpımıyla a’yı kendisi ile çarparsak, a2 matrisini elde ederiz. Matris çarpımı tanımından hatırlamalısınız ki, Bu toplamı, G grafiği açısından yorumlarsak, bu formül köşe sayısını, k, sayar. Burada, G, hem (i, k) ve hem (k, j) kenarlarını içermelidir. Yani, k, ara köşeleri üzerinden, i’den j’ye uzunluğu tam olarak iki olan yol sayısını sayar. Bu gözlem, sadece O(log n) matris çarpımı kullanır, ve G’nin bütün köşe çiftleri arasındaki en kısa yolları hesaplayan bir algoritmanın temelidir. | 409 Bitişiklik Listeleri: Liste Derlemi olarak Grafik Grafiklerin bitişiklik listesi ile gösterimleri daha köşe-merkezli bir yaklaşım alır. Bitişiklik listelerinin birçok olası uygulamaları vardır. Bu bölümde, basit bir tanesini tanıtacağız. Bölümün sonunda, farklı olasılıkları tartışacağız. Bitişiklik listeleri gösteriminde, G = (V, E) grafiği bir liste dizisi, adj, halinde temsil edilir. adj[i] listesi, i köşesine bitişik tüm köşelerin bir listesini içerir. Yani, (i, j) E olan her j endeksini içerir. Şekil 12.3 bir örneği gösteriyor. Bu özel uygulamada, adj içindeki her listeyi bir Dizi Yığıt olarak temsil ediyoruz, çünkü konuma göre erişim için sabit çalışma zamanı istiyoruz. Diğer seçenekler de mümkündür. Özellikle, bir Çifte Bağlantılı Liste olarak da adj’i uygulayabilirdik. 410| addEdge(i, j) işlemi, adj[i] listesine j değerini sadece ekler: | 411 Bu sabit zaman alır. removeEdge(i, j) işlemi, adj[i] listesinde j değerini bulana kadar arar, ve bulduğunda siler: Bu, O(deg(i)) zaman alır, burada deg(i), (i’nin derecesi) E içinde kaynağı i olan kenar sayısını sayar. hasEdge(i, j) işlemi de benzerdir; adj[i] listesinde j değerini bulana kadar arar (ve true döndürür), veya listenin sonuna ulaşır (ve false döndürür): 412| Bu, O(deg(i)) zaman alır. outEdges(i) işlemi çok basittir; adj[i] listesini döndürür: Bu, açıkça, sabit zaman alır. inEdges(i) işlemi, çok daha fazla iş gerektirir. Her j köşesi üzerin- den tarayarak, (i, j) kenarının bulunup bulunmadığını kontrol eder, ve eğer bulduysa, j’yi çıktı listesine ekler: Bu işlem çok yavaştır. Her köşenin bitişiklik listesini tarar, bu nedenle O(n + m) zaman alır. Aşağıdaki teorem yukarıdaki veri yapısının performansını özetlemektedir: Teorem 12.2. Bitişiklik Listeleri veri yapısı, Grafik arayüzünü uygular. Bitişiklik Listeleri aşağıdaki işlemleri destekler: | 413 İşlem başına sabit zamanda çalışan addEdge(i, j); İşlem başına O(deg(i)) zamanda çalışan removeEdge(i, j) ve hasEdge(i, j); İşlem başına sabit zamanda çalışan outEdges(i); ve İşlem başına O(n + m) zamanda çalışan inEdges(i). Bitişiklik Listeleri O(n + m) alan kullanır. Daha önce değindiğimiz gibi, bir grafiği bitişiklik listesi halinde uygularken, karar verilmesi gereken pek çok farklı seçenek vardır. Öne çıkan bazı sorular şunları içermektedir: Her adj elemanını depolamak için ne tür bir derlem kullanılmalıdır? Bir dizi-tabanlı liste, bir bağlantılı liste, hatta bir karma tablosu kullanılabilir. İkinci bir bitişiklik listesi, inadj, olmalı mıdır? Bu liste, her i köşesi için, (j, i) E olan j köşe listesini depolar. Böylece, inEdges(i) işleminin çalışma zamanı büyük ölçüde azaltıla- bilir, ancak kenarları eklerken veya silerken biraz daha fazla iş gerektirir. adj[i] içindeki (i, j) kenarı, inadj [j] içinde kendisine karşı- lık gelen girdiye bir referansla bağlanmalı mıdır? Kenarlar kendilerine ilişkili verileri ile birinci sınıf nesneler olmalı mıdır? Bu şekilde, adj, köşe (tamsayı) listesini değil, kenar listesini içerecektir. 414| Bu soruların çoğu uygulamanın karmaşıklığı (ve alan gereksinimi) ile uygulamanın performans özellikleri arasında bir tercihte bulunmayı beraberinde getirir. | 415 Grafik Ziyaretleri Bu bölümde, bir grafiği incelemek için, grafiğin köşelerinden biri olan, i köşesinden başlayarak, i’den ulaşılabilir bütün köşeleri bulan iki algoritma tanıtacağız. Bu algoritmaların ikisi de, bitişiklik listesi gösterimini kullanan grafikler için uygundur. Bu nedenle, bu algoritmaları analiz ederken, Bitişiklik Listeleri gösterimini temel olarak varsayacağız. 416| Enine-Arama Enine-arama algoritması, i, köşesinden başlar ve ilk olarak, i’nin komşularını ziyaret eder, sonra i’nin komşularının komşularını ziyaret eder, sonra i’nin komşularının komşularının komşularını ziyaret eder, vb. Bu algoritma, ikili ağaçlar için enine-arama algoritmasının (bkz. İkili Ağaçta Sıralı-Düğüm Ziyaretleri Bölümü) bir genellemesidir ve çok benzerdir; başlangıçta sadece i’yi içeren, q kuyruğunu kullanır. Sonra q’dan bir eleman çıkarır ve komşularını daha önceden eklenmediyse q’ya ekler. Bunu tekrarlayarak defalarca yapar. Enine-arama algoritmasının grafik versiyonu ile ağaç versiyonu arasındaki tek büyük fark, grafik algoritmasının q köşesini birden fazla kere eklememesidir. Bunu sağlamak için, hangi köşelerin incelenmiş olduğunu tutan bir yardımcı boolean dizi, seen, kullanılır. | 417 Şekil 12.1’deki grafik üzerinde, bfs(g, 0) çalıştırılmasına bir örnek, Şekil 12.4’de gösterilmiştir. Bitişiklik listelerinin sırasına bağlı olarak, farklı çalıştırmalar mümkündür; Şekil 12.4, Şekil 12.3’teki bitişiklik listelerini kullanmaktadır. bfs(g, i) yordamının çalışma zamanını analiz etmek oldukça basit- tir. seen dizisinin kullanılmasıyla, hiçbir köşe q’ya birden fazla kere eklenmeyecektir. q’ya bir köşe eklemek (ve sonra silmek) köşe başına sabit zaman alır, bu O(n) toplam zaman eder. Her bir köşe, iç döngü tarafından, en fazla bir defa işlendiği için, her bitişiklik listesi, en fazla bir kere işlenir, yani G’nin her kenarı en fazla bir defa işlenir. İç döngü içinde yapılan bu işlem, yineleme başına sabit zaman alır, bu O(m) toplam zaman eder. Bu nedenle, algoritmanın tamamı O(n + m) zamanda çalışır. 418| Aşağıdaki teorem bfs(g, r) algoritmasının performansını özetlemektedir. Teorem 12.3. Bitişiklik Listeleri veri yapısını kullanan bir g Grafik girdisi için, bfs(g, r) algoritması O(n+m) zamanda çalışır. Enine-aramanın çok özel bazı özellikleri vardır. bfs(g, r) çağrısı, r’den j’ye yönlü bir yolu olan her j köşesini, eninde sonunda kuy- ruğa ekler (ve sonunda kuyruktan siler). Ayrıca, r’ye 0 mesafesindeki köşeler (yani, r’nin kendisi), 1 mesafesindeki köşelerden önce q’ya eklenecektir. 1 mesafesindeki köşeler, 2 mesafesindeki köşe- lerden önce q’ya eklenecektir, vb. Bu nedenle, bfs(g, r) işlemi, r’ye olan mesafesi artan sırada olacak şekilde köşeleri ziyaret eder, ve r tarafından ulaşılamayan köşeleri ziyaret etmez. Enine-arama algoritmasının özellikle yararlı bir uygulaması, bu nedenle, en kısa yolları hesaplamaktır. r’den diğer her köşeye en kısa yolu hesaplamak için bfs(g, r) yordamının bir varyasyonunu kullanıyoruz. Bu kod, n uzunluğunda bir p yardımcı dizisi kullanır. Yeni bir j köşesi, q’ya eklendiğinde, p[j] = i olarak belirleriz. Bu şekilde, r’den j’ye giden en kısa yol üzerindeki ikinci son düğüm p[j] olur. r’den j’ye giden en kısa yolu (tersine) yeniden kurmak için bunu tekrarlarız, p[p[j], p[p[p[j]]], vb. | 419 Derinliğine Arama Derinliğine-arama algoritması ikili ağaçları inceleyen standart algoritmaya benzer; geçerli düğüme dönmeden önce altağaçlardan birini tamamen incelemeyi bitirir, ve sonra başka bir altağacı araştırır. Derinliğine-arama, enine-aramayla bir fark dışında benzeşir, kuyruk yerine yığıt kullanır. Derinliğine-arama algoritmasının çalışması sırasında, her i köşesine, bir renk, c[i] atanır: Daha önce köşeyi görmemişsek white (beyaz), şu anda bu köşeyi ziyaret ediyorsak gray (gri), ve bu köşeyi ziyaret etmeyi bitirdiysek black (siyah). Derinliğine-aramayı düşünmenin en kolay yolu, onu bir özyinelemeli algoritma olarak düşünmektir. r köşesini ziyaret ederek başlarız. i köşesini ziyaret ederken, i’yi gri olarak işaretleriz. Sonra, i’nin bitişiklik listesini tararız ve bu listede bulduğumuz herhangi bir beyaz köşeyi özyinelemeli olarak ziyaret ederiz. Sonunda, i’yi işlemeyi tamamladığımızda, i’yi siyah renkle işaretleriz ve dönüş sağlarız. 420| Şekil 12.5 bu algoritmanın çalışmasına bir örnek gösteriyor. Derinliğine-arama en iyi şekilde özyinelemeli olarak düşünülse de, özyineleme bunu uygulamak için en iyi yol değildir. Nitekim, yukarıda verilen kod, birçok büyük grafik için yığıt taşmasına yol | 421 açarak başarısız olacaktır. Alternatif bir uygulama, açık bir yığıt olan, s’in, özyineleme yığıtının yerine geçmesidir. Aşağıdaki uygulama tam olarak bunu yapar: Yukarıdaki kodda, bir sonraki i köşesi işlendiği zaman, i, gri renge boyanır ve sonra, yığıt üzerinde, bitişik köşeler ile yer değiştirir. Sonraki yineleme sırasında, bu köşelerden biri ziyaret edilecektir. Beklendiği gibi, dfs(g, r) ve dfs2(g, r) çalışma zamanları bfs(g, r) ile aynıdır: Teorem 12.4. Bitişiklik Listeleri veri yapısı kullanan g Grafik girdisi için, dfs(g, r) ve dfs2(g, r) algoritmalarının her biri O(n + m) zamanda çalışır. Enine-arama algoritmasında olduğu gibi, derinliğine-aramanın her çalıştırması ile ilişkili altta yatan bir ağaç vardır. i r olan bir dü- 422| ğüm, beyazdan griye renk değiştirdiğinde, bunun nedeni, bir i’ düğümünü işlerken özyinelemeli olarak dfs(g, i, c) yönteminin çağrılmasıdır (dfs2(g, r) algoritması için, yığıtta i’ düğümünün yerini alan düğümlerden biri i’dir). Eğer i babası i’ ise, o zaman r kökenli bir ağaç elde ederiz. Şekil 12.5’te bu ağaç köşe 0’dan köşe 11’e giden bir yoldur. Derinliğine-aramanın önemli bir özelliği şudur: Varsayalım ki, i düğümü gri renklendirildiğinde, i’den diğer bazı j düğümü için sadece beyaz köşeleri kullanan bir yol vardır. O zaman, j ilk olarak gri renkli olacak, sonra i siyah olmadan önce siyah renkli olacaktır (i’den j’ye herhangi bir, P yolunu dikkate alan çelişki yöntemi ile kanıtlanabilir). Bu özelliğin bir uygulaması, döngülerin saptanmasıdır. Şekil 12.6’ya bakın. r’dan ulaşılabilir bir, C döngüsünü düşünün. i, C'nin ilk gri renkli düğümü olsun, ve C döngüsü üzerinde i’den önce gelen düğüm j olsun. | 423 Sonra, yukarıda belirtilen özellikle, j gri renkli olacak ve i hala gri iken (j, i) kenarı algoritma tarafından dikkate alınacaktır. Bu nedenle, derinliğine-arama ağacında i’den j’ye bir yol, P, olduğu ve (j, i) kenarının bulunduğu sonucuna varılabilir. Bu nedenle, P de bir döngüdür. 424| Tartışma ve Alıştırmalar Derinliğine-arama ve enine-arama algoritmalarının çalışma zamanları Teorem 12.3 ve 12.4 tarafından biraz büyütülmüştür. nr, r’dan i için bir yol bulunan G’nin köşe sayısı olsun. mr bu köşeleri kaynak olarak alan kenar sayısını belirtsin. O zaman, aşağıdaki teorem enine-arama ve derinliğine-arama algoritmalarının çalışma zamanlarını daha kesin bir ifadeyle vermektedir (Bu daha gelişmiş ifade, alıştırmalarda hazırlanan bazı algoritmaların uygulamalarında yararlı olacaktır). Teorem 12.5. Bitişiklik Listeleri veri yapısı kullanan g Grafik girdisi için, bfs(g, r), dfs(g, r) ve dfs2(g, r) algoritmalarının her biri O(nr + mr) zamanda çalışır. Enine-arama Moore [52] ve Lee [49] tarafından, sırasıyla, labirent keşif ve devre yönlendirme bağlamlarında bağımsız olarak keşfedilmiştir. Grafiklerin Bitişiklik Listesi gösterimleri, Hopcroft ve Tarjan [40] tarafından, (o zaman daha yaygın olan) Bitişiklik Matrisi gösterimine bir alternatif olarak tanıtıldı. Bu gösterim, derinliğine-arama ile birlikte, ünlü Hopcroft-Tarjan düzlemsellik test algoritmasında önemli bir rol oynadı. Bu algoritma ile, O(n) zamanda, hiçbir kenar çifti birbirini kesmeyecek şekilde bir grafiğin [41] düzlemde çizilip çizilemeyeceğini belirleyebilirsiniz. | 425 Aşağıdaki alıştırmalarda, her i ve j için (i, j) kenarı, ancak ve ancak (j, i) kenarı mevcutsa bulunan bir grafiğe yönsüz grafik denir. Alıştırma 12.1. Şekil 12.7’de gösterilen grafiğin Bitişikliklik Listesi gösterimini ve Bitişiklik Matrisi gösterimini çizin. Alıştırma 12.2. G grafiğinin yük matrisi gösterimi, aşağıdaki gibi A ile tanımlanan n x m matristir: 426| 1. Şekil 12.7’de gösterilen grafiğin yük matrisi gösterimini çizin. 2. Bir grafiğin yük matrisi gösterimini tasarlayın, analiz edin ve uygulayın. addEdge(i, j), removeEdge(i, j), hasEdge(i, j), inEdges(i), ve outEdges(i) alan gereksinimini ve çalışma zamanla- rını analiz ettiğinizden emin olun. Alıştırma 12.3. Şekil 12.7’deki G grafiği üzerinde bfs(G, 0) ve dfs(G, 0) çalıştırmasını gösterin. Alıştırma 12.4. G yönsüz grafik olsun. Her i, j köşe çifti için i’den j’ye bir yol varsa (G yönsüz grafik olduğu için j’den i’ye de bir yol vardır) G grafiği bağlı bir grafiktir. G’nin bağlı olup olmadığını, O(n + m) zamanda nasıl test edeceğinizi gösterin. Alıştırma 12.5. G yönsüz grafik olsun. G’nin bağlı-bileşen etiketlemesi G köşelerini en büyük kümeler halinde bölümlere ayırır. Bunların her biri, bağlı birer altgrafiktir. G’nin bağlı-bileşen etiketlemesini, O(n+m) zamanda nasıl hesaplayacağınızı gösterin. Alıştırma 12.6. G yönsüz grafik olsun. G’yi kapsayan orman, bileşen başına, G kenarlarından ve G’nin bütün köşelerinden oluşan bir ağaç topluluğudur. G’yi kapsayan ormanı, O(n + m) zamanda nasıl hesaplayacağınızı gösterin. Alıştırma 12.7. G grafiğinin her i, j köşe çifti için i’den j’ye bir yol varsa kuvvetli-bağlı olduğu söylenir. G’nin kuvvetli-bağlı olup olmadığını, O(n + m) zamanda nasıl test edeceğinizi gösterin. | 427 Alıştırma 12.8. G = (V, E) grafiği, ve bir özel köşesi, r r’dan i’ye giden en kısa yolun uzunluğunu, her i V V için, köşesi için, nasıl hesaplayacağınızı gösterin. Alıştırma 12.9. dfs(g, r) kodunun grafik düğümlerini ziyaret etmesine (basit) bir örnek verin. Bu örnekte, düğümler dfs2(g, r)’den farklı bir sırada ziyaret edilmelidir. Düğümleri tam olarak dfs(g, r) ile aynı sırada ziyaret eden dfs2(g, r)’in bir versiyonunu yazın (İpucu: r birden fazla kenar için kaynak iken, her iki algoritmanın da grafik üzerinde çalışmasını izleyin). Alıştırma 12.10. G grafiğinde evrensel çıkış düğümü, n – 1 kenarın hedefi olan, ancak hiçbir kenara kaynak olmayan bir köşedir. Bitişiklik Matrisi ile gösterilen bir G grafiğinin, evrensel çıkış düğümü- nün var olup olmadığını test eden bir algoritma tasarlayın ve uygulayın. Algoritmanız O(n) zamanda çalışmalıdır. 428| | 429 Bölüm 13 Tamsayılar için Veri Yapıları Bu bölümde, Sıralı Küme’nin uygulanması problemine geri dönüyoruz. Şu anki fark, Sıralı Küme’de depolanan elemanların w-bit tamsayılar olarak varsayılmasıdır. Yani, x le(x), sil(x), {0, 2 w – 1} için ek- ve bul(x) işlemlerini uygulamak istiyoruz. Pek çok uygulama için verinin – veya en azından veri sıralamak için kullandığımız anahtarın – tamsayı olduğunu düşünmek zor olmayacaktır. Fikirleri bir öncekinin üzerine kurulu üç veri yapısını tartışacağız. İlk yapı, İkili Sıralı Ağaç, her zaman Sıralı Küme işlemlerinin üçünü de, O(w) zamanda gerçekleştirir. Bu çok etkileyici değildir, çünkü {0,…,2w – 1} içinden herhangi bir alt küme n ≤ 2w boyutuna sahiptir, ve böylece log n ≤ w. Bu kitapta tartışılan diğer bütün Sıralı Küme uygulamalarının tüm işlemleri O(log n) zamanda çalışır, bu nedenle en azından bir İkili Sıralı Ağaç kadar hızlıdır. İkinci yapı X-Hızlı Sıralı Ağaç, karmayı kullanarak İkili Sıralı Ağaç içinde yapılan aramayı hızlandırır. Bu hızlandırmayla, bul(x) işlemi O(log w) zamanda çalışır. Ancak, ekle(x) ve sil(x) işlemleri, hala X-Hızlı Sıralı Ağaç O(n . w) olur. içinde O(w) zaman alır, ve kullanılan alan 430| Üçüncü yapı Y-Hızlı Sıralı Ağaç, her w elemanı içinden sadece bir örneği depolamak için X-Hızlı Sıralı Ağaç’ı kullanır, ve kalan elemanları standart bir Sıralı Küme yapısında depolar. Böylece ekle(x) ve sil(x) çalışma zamanı O(log w) ve alan gereksinimi O(n)’ye kadar azalır. Bu bölümde örnek olarak kullanılan uygulamalar, bir tamsayı ile ilişkili her türlü veri türünü depolayabilir. Kod örneklerinde, ix değişkeni, her zaman x tamsayı değeri ile ilişkilidir, ve in.intValue(x) yöntemi, x ile ilişkili tamsayıyı dönüştürüyor. | 431 İkili Sıralı Ağaç: Sayısal Arama Ağacı İkili Sıralı Ağaç, w-bit tamsayılardan oluşan bir kümeyi ikili ağaç içine kodlar. Ağaçtaki tüm yapraklar w derinliğindedir ve her tamsayı kökten-yaprağa giden bir yol olarak kodlanmıştır. i’nci en anlamlı bit, 0 ise, x tamsayısı için yol i seviyesinde sola doğru döner. 1 ise sağa döner. Şekil 13.1, w = 4 durumu için, 3 (0011), 9 (1001), 12 (1100), 13 (1101) tamsayılarının depolandığı örnek bir ağacı gösteriyor. x değeri için arama yolu, x bitlerine bağlı olduğu içindir ki, bir u düğümünün çocuklarını, u.child[0] (sol) ve u.child[1] (sağ) olarak isimlendirmek yararlı olacaktır. child olarak adlandırılan bu işaretçilerin birden çok fonksiyonu vardır. İkili Sıralı Ağaç’ın yapraklarında çocuk olmadığı için, işaretçilerin fonksiyonu yaprakları bir Çifte-Bağlantılı Liste (ÇBListe) Sıralı Ağaç halinde bir araya getirmektir. İkili içindeki bir yaprak için, u.child[0] (prev), listede u’dan önce gelen düğümdür. u.child[1] (next) listede u’dan sonra gelen düğümdür. Özel bir düğüm, dummy, hem ilk düğümün öncesinde, hem son düğümün sonrasında kullanılır (bkz. ÇBListe: ÇifteBağlantılı Liste Bölümü). Her, u, düğümü ayrıca u.jump adında bir ek işaretçi içerir. u düğümünün solundaki çocuğu mevcut değilse, u.jump, u altağacındaki en küçük yaprağa işaret eder. Sağındaki çocuk mev- 432| cut değilse, u.jump, u altağacındaki en büyük yaprağa işaret eder. jump işaretçilerini gösteren bir İkili Sıralı Ağaç örneği ve yaprakla- rı Çifte-Bağlantılı Liste halinde Şekil 13.2’de gösterilmiştir. İkili Sıralı Ağaç’ta bul(x) işlemi oldukça kolaydır. Arama yolunun başlangıcında, u düğümleri arasından x yaprağı aranır. Eğer öyleyse, x bulunmuş olarak hesaplanır. u düğümünden öteye gidilemezse, (x’in çocuğu yoksa, yani yaprağa ulaşıldıysa), u.jump yolu aranır. Bu arama, bizi x’den büyük en küçük yaprağa, veya x’den küçük en büyük yaprağa götürür. Bu iki durumdan, hangisinin önce oluşacağını, u düğümünün sol çocuğunun mu, sağ çocuğunun mu, sırasıyla, eksik, veya var olmasına bağlayabiliriz. Birinci durumda (u’nun sol çocuğu eksik), istediğimiz düğüm bulunmuş olur. İkinci durumda (u’nun sağ çocuğu eksik), istediğimiz düğüme ulaşmak için bağlantılı listeyi kullanabiliriz. Bu durumların her biri, Şekil 13.3’te gösterilmiştir. | 433 bul(x) işleminin çalışma zamanı, kökten yaprağa aldığı yol ile be- lirlenir, bu nedenle O(w) zamanda çalışır. İkili Sıralı Ağacı’nda ekle(x) işlemi kolay, ancak oldukça zahmetli- dir: 1. Arama yolu üzerinde u düğümü için, ulaşılabilen son düğüme kadar arama yapılır. 2. u düğümünden başlayarak, arama yolunun kalanı için, x içeren bir yaprağa kadar arama yolu kaydedilir. 3. x içeren bir u’ düğümü oluşturularak bağlantılı yaprak listesine eklenir (Birinci adımda en son ziyaret edilen, u düğümüne ait olan jump işaretçisinin gösterdiği bağlantılı listenin içinden u’ öncesine, pred, erişim sağlar). 434| 4. x arama yolu üzerinde geri yürüyerek, şimdi x’i gösteren jump işaretçilerinin bulunduğu düğümlerde jump işaretçile- ri ayarlanır. Şekil 13.4 örnek bir ekleme çalıştırmasını gösteriyor. Bu işlemin çalıştırılması sırasında, x için önce ileri, sonra geri yönde birer arama yolu bulunuyor. Bu yürüyüşlerin her iki adımı da sabit zamanda çalışır, bu nedenle ekle(x) işlemi O(w) zamanda çalışır. | 435 436| sil(x) işlemi ekle(x) işini geri alır. ekle(x) gibi, yapması gereken pek çok iş vardır: | 437 1. x için arama yolu üzerinden x içeren u yaprağına ulaşana kadar arar. 2. Çifte-bağlantılı listeden u’yu siler. 3. u silindikten sonra, x için arama yolu üzerinde olmayan bir çocuğa sahip v düğümüne ulaşılana kadar arama yolu ardı sıra silinir. 4. u’ya işaret veren her jump işaretçisini güncellemek için başlangıcı v, sonu kök olan yeni bir yol oluşturulur. Şekil 13.5 örnek bir silme çalıştırmasını gösteriyor. Teorem 13.1. İkili Sıralı Ağaç, w-bit tamsayılar için Sıralı Küme arayüzünü uygular. İkili Sıralı Ağaç, işlem başına O(w) zamanda çalışan, ekle(x), sil(x), ve bul(x) işlemlerini destekler. n değer depolayan İkili Sıralı Ağacı O(n . w) alan kullanır. 438| | 439 X-Hızlı Sıralı Ağaç: Çifte-Logaritmik Zamanda Arama İkili Sıralı Ağaç yapısının performansı çok etkileyici değildir. Veri yapısında depolanan eleman sayısı, n, en çok 2W olur, bu nedenle log n ≤ w yazılabilir. Diğer bir deyişle, bu kitabın diğer bölümle- rinde tanıtılan, karşılaştırmaya-dayalı Sıralı Küme yapılarının herhangi biri, en az İkili Sıralı Ağaç’lar kadar verimlidir, ve sadece tamsayıları depolamakla sınırlı değildir. Bu bölümde X-Hızlı Sıralı Ağaç yapısı tanıtılıyor. Bu yapının her seviyesinde, birer w + 1 karma tabloya sahip İkili Sıralı Ağacı bulunmaktadır. Bu karma tablolar, bul(x) işleminin O(log w) zamanda çalışması için, hızlandırma amaçlı kullanılır. Hatırlayın ki, İkili Sıralı Ağaç’ta bul(x) u işlemi, x için bir arama yolu üzerinde, öyle bir düğümüne ulaştığımız zaman tamamlanmalıdır ki, u.right (veya u.left) üzerinden ilerlemek istediğimizde, u’nun sağ (sırasıyla, sol) çocuğunu bulamamalıyız. Bu noktada, arama, u.jump yardımıyla, İkili Sıralı Ağacı’nın bir, v yaprağına atlamalıdır, ve v’yi, veya yap- rakları depolayan bağlantılı-listede, v’den sonra gelen düğümü döndürmelidir. X-Hızlı Sıralı Ağaç, ağaç seviyeleri üzerinde ikili aramayı çalıştırarak, u düğümünü bulmak için geçen arama sürecini hızlı hale getirir. İkili aramayı kullanmak için, aradığımız u düğümünün belirli bir i seviyesinin üstünde mi, yoksa i seviyesinde veya altında mı sorusu- 440| nu karara bağlamamız lazımdır. Bu bilgi, x’in ikili gösteriminde en önemli i biti ile verilmektedir; bu bitler kökten i’nci seviyeye x’i taşıyan arama yolunu belirler. Örneğin, bkz. Şekil 13.6. Bu şekil üzerinde, 14 için (ikili gösterimi 1110) arama yolunun son düğümü, u, 2.seviyede ile etiketlenmiştir, çünkü 3.seviyede ile etiketli herhangi bir düğüm yoktur. Böylece, i seviyesinde bulunan her düğümü, i-bitlik bir tamsayı ile etiketleyebiliriz. x’nin en önemli i-bitinden oluşan etikete sahip bir düğüm, ancak ve ancak, i seviyesinde bulunuyorsa, aradığımız u düğümü, i seviyesinde veya altında yer alır. Her i {0,…,w} için, X-Hızlı Arama Ağacı’nın i seviyesinde bulu- nan bütün düğümlerini, bir Sırasız Küme içinde depolarız. Bu Sırasız Küme, karma tablo olarak uygulanan t[i] ile verilmiştir (bkz. Bölüm 5). x’in en önemli i-biti ile etiketlenmiş bir düğümün i sevi- | 441 yesinde var olup olmadığını kontrol etmemize olanak tanır. Bu kontrolü beklenen sabit zamanda gerçekleştiririz. Gerçekte bu düğümü, t[i].bul(x t[0]…t[w] (w – i)) kullanarak da bulabiliriz. karma tabloları, ikili aramayı kullanarak, u’yu bulmamı- za olanak tanır. Başlangıçta, u’nun 0 ≤ i w+1 için bazı i seviye- sinde olduğunu biliyoruz. Bu nedenle, l = 0 ve h = w + l ile başlıyoruz, ve bakıyoruz. Eğer olan t[i], x’in t[i] karma tablosuna tekrar tekrar en önemli i-biti ile etiketli bir düğümü içeriyorsa, l = i olarak belirleriz (u, i seviyesinde veya altındadır); aksi takdirde, h = i olarak belirleriz (u, i seviyesinin üstündedir). h – l ≤ 1 koşulu, bu işlemi sonlandırır, çünkü l seviyesinde u’nun yeri belirlenmiştir. Sonra, u.jump ve yaprakların çifte-bağlantılı listesini kullanarak bul(x) işlemini tamamlarız. 442| Yukarıdaki yöntemde, while döngüsünün her yinelemesi h – l değerini yaklaşık olarak 2 faktör oranında azaltır. Bu nedenle, bu döngü O(log w) yinelemeden sonra u’yu bulur. Her yineleme sabit zamanda iş gerçekleştirir ve Sırasız Küme üzerinde, sabit beklenen zamanda bir bul(x) işlemi gerçekleştirir. Kalan iş, sadece sabit zaman alır, bu nedenle, X-Hızlı Sıralı Ağaç üzerinde bul(x) işlemi, O(log w) beklenen zamanda çalışır. X-Hızlı Sıralı Ağaç Ağaç’ın için ekle(x) ve sil(x) yöntemleri, İkili Sıralı aynı yöntemleri ile hemen hemen aynıdır. Sadece, t[0],….,t[w] karma tablolarını yönetmek için değişiklikler yapılma- sı gereklidir. ekle(x) işlemi sırasında, i seviyesinde yeni bir düğüm oluşturulduğu zaman, bu düğüm t[i] tablosuna eklenir, sil(x) işlemi sırasında, i seviyesinde bir düğüm silindiğinde, bu düğüm t[i] tablosundan silinir. Karma tabloya ekleme veya silme, sabit beklenen zaman aldığı için, ekle(x) ve sil(x) çalışma zamanları, sabit bir faktörden daha fazla artmaz. ekle(x) ve sil(x) için kod dökümünü burada dahil etmiyoruz, çünkü kod, İkili Sıralı Ağaç’ın yöntemleri tarafından sağlanan (uzun) kodun hemen hemen aynısıdır. Aşağıdaki teorem X-Hızlı Sıralı Ağaç performansını özetlemektedir: Teorem 13.2. X-Hızlı Sıralı Ağaç, w-bit tamsayılar için Sıralı Küme arayüzünü uygular. X-Hızlı Sıralı Ağaç aşağıdaki işlemleri destekler: | 443 İşlem başına O(w) beklenen zamanda çalışan ekle(x), sil(x) ve, İşlem başına O(log w) beklenen zamanda çalışan bul(x). n değer depolayan X-Hızlı Sıralı Ağaç O(n . w) alan kullanır. 444| Y-Hızlı Sıralı Ağaç: Çifte-Logaritmik Zamanlı Sıralı Küme X-Hızlı Sıralı Ağaç, sorgu zamanı açısından, İkili Sıralı Ağaç ile kıyaslandığında, oldukça büyük –hatta üstel – bir gelişme sağlar, ancak ekle(x) ve sil(x) işlemleri hala istenildiği kadar hızlı değildir. Ayrıca, alan kullanımı, O(n . w), bu kitapta anlatılan ve kullanım alanı O(n) olan tüm diğer Sıralı Küme uygulamalarından daha yüksektir. Bu iki sorun ilişkilidir; ekle(x) işlemi n defa çalıştırılarak boyutu n . w olan bir yapı kurulursa, ekle(x) işlemi, işlem başına en azından w cinsinden bir zaman (ve alan) gerektirir. Ardından tartışılan Y-Hızlı Sıralı Ağaç, X-Hızlı Sıralı Ağaç’ın alanını ve hızını aynı anda iyileştirir. Y-Hızlı Sıralı Ağaç, X-Hızlı Sıralı Ağaç’ı, xft, kullanır, ancak xft içinde sadece O(n/w) değer depolar. Bu şekilde, xft tarafından kullanılan toplam alan sadece O(n) olur. Ayrıca, Y-Hızlı Sıralı Ağaç içindeki her w ekle(x), veya sil(x) işleminden sadece biri, xft içinde bir ekle(x) veya sil(x) işlemiyle sonuçlanır. Bunu yaparak, xft’nin ekle(x) ve sil(x) işlemleri için yaptığı çağrıların ortalama maliyeti sadece sabit olur. Açıkça şunu sormalıyız: xft sadece n/w eleman depoluyorsa, geride kalan n(1 – 1/w) eleman nereye gider? Bu elemanlar ikincil yapıların içine, bu durumda genişletilmiş bir Treaps versiyonunun (bkz. Treap: Randomize İkili Arama Ağaçları Bölümü) içine taşınmıştır. Bu ikincil yapılardan, ortalama olarak, yaklaşık n/w tane | 445 vardır, her biri O(w) eleman depolar. Treaps, logaritmik zamanda çalışan Sıralı Küme işlemlerini desteklemektedir, bu nedenle bu Treap’ler üzerindeki işlemler gerektiği gibi, O(log w) zamanda çalışacaktır. Daha somut olarak, Y-Hızlı Sıralı Ağaç, her elemanın bağımsız olarak 1/w olasılıkla göründüğü bir rasgele veri örneği olan X-Hızlı Sıralı Ağaç’ı, xft, içerir. Kolaylık sağlaması için, 2w – 1 değeri, her zaman içindedir. x0 x1 xft’nin ... xk-1 xft içinde depolanan elemanlar ile ifade edilsin. Şekil 13.7’de gösterildiği gi- bi, her xi elemanı ile ilişkili, xi–1 + 1,...,xi aralığındaki tüm değerleri depolayan bir treap, ti, vardır. Y-Hızlı Sıralı Ağaç x içinde bul(x) işlemi oldukça kolaydır. xft içinde ararız, ve treap, ti, ile ilişkili bazı xi değeri buluruz. Sonra sorgu- yu cevaplandırmak için treap bul(x) yöntemini ti üzerinde çalıştırırız. Tüm kod, bir satırdan oluşmaktadır: Birinci bul(x) işlemi (xft üzerinde) O(log w) zamanda çalışır. İkinci bul(x) işlemi (treap üzerinde), O(log r) zamanda çalışır. Burada r, treap boyutudur. 446| İlerleyen bölümlerde, treap’in beklenen boyutunun O(w) olduğunu göstereceğiz, böylece bu işlem O(log w) zamanda çalışacaktır. Y-Hızlı Sıralı Ağaç içine bir eleman eklemek de – çoğu zaman – oldukça kolaydır. Önce x’in içine gireceği treap, t’yi bulmak için ekle(x) yöntemi xft.bul(x) çağrısı yapar. Sonra x’i, t içine eklemek için t.ekle(x) çağrısı yapar. Bu noktada, 1/w olasılığıyla, tura gelen ve 1 – 1/w olasığıyla yazı gelen hileli parayı fırlatır. Tura geldiyse, xft içine x eklenecektir. | 447 İşlerin biraz daha karışık hale geldiği yer burasıdır. xft içine x eklendiğinde, treap t’nin iki treaps haline, t1 ve t’ olmak üzere, ayrılması gerekir. t1 treap değerlerinin tümü, x’den daha küçük veya eşittir. t’, orijinal t treap’i içinden t1 elemanlarının çıkarılmasıyla elde edilir. Bu işlem bir kez yapıldıktan sonra, xft içine (x, t1) çiftini ekleriz. Şekil 13.8 bir örneği gösteriyor. 448| t içine x eklenmesi O(log w) zamanda çalışır. Alıştırma 7.12, t’nin, t1 ve t’ halinde ayrılmasının da O(log w) beklenen zamanda yapı- labileceğini gösteriyor. xft içine (x, t1) çiftinin eklenmesi O(w) zaman alır, ancak sadece 1/w olasılığıyla gerçekleşir. Bu nedenle, ekle(x) işlemi, beklenen zamanda çalışır. sil(x) işlemi, ekle(x) tarafından gerçekleştirilen işleri geri alır. xft.bul(x) sonucunda xft içinde u yaprağını buluruz. u’dan, x’i içe- ren t treap’ini elde ederiz, ve x’i t’den sileriz. x, xft’de de depolanmışsa (x, 2w – 1’e eşit değilse), x’i xft’den sileriz, ve x treap’inin içindeki elemanları, bağlantılı listede u’nun ardından gelen, t2 treap’inin içine ekleriz. Şekil 13.9’da bu gösterilmiştir. | 449 xft içinde u düğümü, O(log w) beklenen zamanda bulunur. t’den x, O(log w) beklenen zamanda silinir. Yine, Alıştırma 7.12, t içindeki tüm elemanları O(log w) zamanda t2 içinde birleştirebileceğinizi göstermektedir. Gerekirse, xft’den x, O(w) zamanda silinir, ancak x yalnızca 1/w olasılığı ile xft’de yer almaktadır. Bu nedenle, Y-Hızlı Sıralı Ağaç’tan bir eleman O(log w) beklenen zamanda silinir. Daha öncesinde, bu yapıda treap’lerin boyutlarını tartışmayı erteledik. Bu bölümü bitirmeden önce, ihtiyacımız olan sonucu kanıtlayacağız. 450| Önerme 13.1. x, Y-Hızlı Sıralı Ağacı’nda depolanan bir tamsayı olsun, ve x’i içeren t treap’inde bulunan eleman sayısı nx ile gösterilsin. E[nx] ≤ 2w – 1 olur. Kanıt. Y-Hızlı Sıralı Ağaç’ta depolanan elemanlar, x1 xi = x x’e xi+1 … xn ile x2 … ifade edilsin; bkz. Şekil 13.10. t treap’i, eşit veya daha büyük bazı elemanları içeriyor. Bu elemanlar, xi , xi+1, …, xi+j-1 ise, ekle(x) işleminde fırlatılan hileli paranın tura olarak döndüğü tek eleman xi+j-1 olarak hesaplanır. Diğer bir deyişle, E[j], ilk turayı elde etmek için gereken hileli para fırlatmanın beklenen sayısına eşittir. Her yazı tura atma bağımsızdır ve tura gelme olasılığı E[j] ≤ w (w = 2 1/w olarak ortaya çıkıyor, bu nedenle, durumunun analizi için, bkz. Önerme 4.2). | 451 Benzer şekilde, x’den daha küçük t elemanları xi–1,…,xi–k ile veriliyor. Burada ilk k para fırlatmanın sonucu yazı ve kalan xi–k–1 para fırlatmanın sonucu tura gelir. Bu, önceki paragrafta ele alınan yazı tura atma deneyinin aynısı olduğu, ancak son para fırlatma sayılmadığı için E[k] ≤ w – 1 olarak hesaplanır. Özetle, nx = j + k, bu nedenle, Y-Hızlı Sıralı Ağaç performansını özetleyen aşağıdaki teoremin ka- nıtının son parçası Önerme 13.1’dir: Teorem 13.3. Y-Hızlı Sıralı Ağaç, w-bit tamsayılar için Sıralı Küme arayüzünü uygular. Y-Hızlı Sıralı Ağaç, ekle(x), sil(x) ve bul(x) işlemlerini, işlem başına O(log w) beklenen zamanda destekler. n değer depolayan Y-Hızlı Sıralı Ağacı O(n + w) alan kullanır. Alan gereksinimindeki w terimi, xft’nin her zaman 2w – 1 değeri depoladığı gerçeğinden ileri gelmektedir. Uygulamada değişiklikler yapılabilir (koda bazı ekstra durumları ekleme pahasına), böylece 452| bu değeri depolamak gereksiz olabilir. Bu durumda, teoremin alan gereksinimi O(n) olur. | 453 Tartışma ve Alıştırmalar ekle(x), sil(x) ve bul(x) işlemlerini O(log w) zamanda gerçekleşti- ren ilk veri yapısı van Emde Boas tarafından önerilmişti ve o zamandan beri van Emde Boas (veya Katmanlı) Ağacı [74] olarak bilinir hale gelmiştir. Orijinal van Emde Boas yapısı 2w büyüklüğündeydi, büyük tamsayılar için bu pratik değildi. X-Hızlı Sıralı Ağaç ve Y-Hızlı Sıralı Ağaç veri yapıları Willard [77] tarafından keşfedildi. van Emde Boas ağaçları ile X-Hızlı Sıralı Ağaç yapısı yakından ilgilidir; örneğin, bir X-Hızlı Sıralı Ağaç’taki karma tabloları, van Emde Boas ağacındaki diziler ile yer değiştirmiştir. Bunun anlamı, t[i] karma tablosunu depolamak yerine, van Emde Boas ağacı 2i uzunluğunda bir diziyi depolar. Tamsayıları depolamak için başka bir yapı da Fredman'in ve Willard'ın füzyon ağaçlarıdır [32]. Bu yapı, n adet w-bit tamsayıları O(n) büyüklüğündeki bir alanda depolayabilir, böylece bul(x) iş- lemi, O((log n / (log w)) zamanda çalışır. da füzyon ağacını kullanarak, ve Sıralı Ağacı lemini olduğunolduğunda Y-Hızlı kullanarak, O(n) alana gereksinimi olan ve bul(x) işzamanda uygulayabilen bir veri yapısı elde edilir. Son zamanlarda Patrascu ve Thorup’un [59] alt sınır ile ilgili sonuçları göstermektedir ki, bu sonuçlar, en azından sadece O(n) alan kullanan yapılar için az veya çok idealdir. 454| Alıştırma 13.1. Bağlantılı listesi veya jump işaretçileri olmayan, İkili Sıralı Ağaç’ın basitleştirilmiş versiyonunu tasarlayın ve uygu- layın. bul(x), O(w) zamanda çalışmalıdır. Alıştırma 13.2. Hiçbir şekilde İkili Sıralı Ağaç kullanmayan, X-Hızlı Sıralı Ağaç’ın basitleştirilmiş versiyonunu tasarlayın ve uygu- layın. Bunun yerine, uygulamanız bir Çifte Bağlantılı Liste’de, ve w +1 karma tabloda herşeyi depolamalıdır. Alıştırma 13.3. İkili Sıralı Ağacı’nı w uzunluğunda bit dizelerini depolayan bir yapı olarak düşünebiliriz. Her bit dizisi, köktenyaprağa bir yolu temsil eder. Sıralı Küme uygulaması olarak bu fikri genişletin. Uygulamanız, değişken uzunluklu dizeleri depolamalı, ve ekle(s), sil(s) ve bul(s) işlemlerini s uzunluğuna orantılı bir zamanda gerçekleştirmelidir. İpucu: Veri yapınızdaki her düğüm, karakter değerleri ile endeksli bir karma tablo depolamalıdır. Alıştırma 13.4. Bir tamsayı x bul(x) {0,…,2w – 1} için, d(x), x ile tarafından döndürülen değer arasındaki farkı göstersin [bul(x) null döndürürse, d(x), 2w olarak tanımlanır]. Örneğin, bul(23), 43 döndürürse, d(23) = 20. 1. X-Hızlı Sıralı Ağaç’ta bul(x) işleminin değiştirilmiş bir versiyonunu tasarlayın ve uygulayın. Bu işlem O(1 + log d(x)) beklenen zamanda çalışmalıdır. İpucu: t[w] karma tablosu, d(x) = 0 olan tüm x değerlerini içerir. Başlamak için burası iyi bir yerdir. | 455 2. X-Hızlı Sıralı Ağaç’ta bul(x) işleminin değiştirilmiş bir versiyonunu tasarlayın ve uygulayın. Bu O(1 + log log d(x)) beklenen zamanda çalışmalıdır. işlem 456| | 457 Bölüm 14 Dış Bellek Aramaları Bu kitap boyunca, Hesaplama Modeli Bölümü’nde tanımlanan w-bit sözcük-RAM hesaplama modelini kullanıyorduk. Bu modelin kesin varsayımı şudur: Bilgisayarımızın rasgele erişim belleği, veri yapısı içindeki tüm verileri depolamak için yeterince büyüktür. Bazı durumlarda, bu varsayım geçerli değildir. O kadar büyük veri koleksiyonları vardır ki, hiçbir bilgisayar bunları depolamak için yeterli belleğe sahip değildir. Bu gibi durumlarda, uygulama, bir sabit disk, katı hal diski, hatta (kendi harici depolaması olan) ağ dosya sunucusu gibi, herhangi bir dış depolama ortamı üzerinde veri depolamaya başvurmalıdır. Harici depolama, eleman erişimi için son derece yavaş bir yöntemdir. Örneğin, bu bilgisayarın sabit diske erişimi ortalama 19 milisaniye, ve katı hal sürücüsüne erişimi 0,3 milisaniye ile verilmiştir. Bunun aksine, bilgisayardaki rasgele erişim belleğinin 0,000113 milisaniyeden daha düşük ortalama erişim zamanı vardır. RAM erişimi, katı hal sürücüsüne erişimden 2.500 kat daha fazla hızlıdır, ve sabit sürücüye erişimden 160.000 kat daha hızlıdır. 458| Bu hızlar oldukça olağandır; rasgele olarak RAM’dan bir bayta erişmek, sabit diskten veya katı hal sürücüsünden erişmekten daha hızlıdır. Ancak binlerce kere daha hızlı olan erişim zamanı, bütün hikayeyi anlatmıyor. Bir sabit disk veya katı hal diskinden bir bayta eriştiğinizde, diskin bütün bir bloğu okunur. Bilgisayara bağlı sürücülerin her birinin 4.096 blok boyutu vardır; biz bir bayt okuduğumuzda, sürücü bize her zaman 4.096 bayt içeren bir blok verir. Dikkatli bir şekilde veri yapısını düzenlersek, her disk erişimi, yaptığımız işi tamamlamak için yararlı olabilecek 4.096 baytı verir. Şekil 14.1’de şematik olarak gösterilen dış bellek modeli hesaplamasının arkasındaki fikir budur. Bu modelde bilgisayar, tüm verilerin bulunduğu büyük bir dış belleğe erişiyor. Bu bellek her biri B sözcük içeren bellek bloklarına ayrılmıştır. Bilgisayar aynı zamanda hesaplamaları gerçekleştirmek için sınırlı bir iç belleğe de sahiptir. İç bellek ve dış bellek arasında bir blok aktarma sabit zaman alır. İç bellek içinde yapılan hesaplamalar bedavadır ve zaman gerektirmez. İç bellek hesaplamalarının bedava olması aslında biraz garip gelebilir, ancak sadece dış belleğin RAM’dan çok daha yavaş olduğu gerçeğini vurgulamaktadır. Tam gelişmiş dış bellek modelinde, iç bellek boyutu da bir parametredir. Ancak, bu bölümde açıklanan veri yapıları için, O(B + logB n) boyutunda bir iç belleğe sahip olmak yeterlidir. | 459 Yani, belleğin sabit sayıda bloğa ve O(logB n) yüksekliğinde bir özyineleme yığınını depolama yeteneğine sahip olması gerekir. Çoğu durumda, bellek gereksinimi için O(B) yeterlidir. Örneğin, hatta nispeten küçük bir B=32 değeri ve her n ≤ 2160 için, B ≥ logB n olarak hesaplanır. Onluk tabanda, her için B ≥ logB n olarak hesaplanır. 460| Blok Deposu Dış bellek kavramı çok sayıda farklı olası cihazları içerir; bunlardan her birinin, kendine ait blok boyutu vardır ve kendi koleksiyonlarına ait sistem çağrıları ile erişilir. Ortak fikirler üzerinde odaklanmak üzere, bu bölümün daha rahat anlaşılması için, BlokDeposu adında bir nesne ile dış bellek cihazlarını kılıflıyoruz. BlokDeposu, her biri B boyutunda olan bellek bloklarının bir koleksiyonunu depolar. Her blok benzersiz tamsayı endeksi ile tanımlanır. BlokDeposu şu işlemleri destekler: 1. readBlock(i): i endeksli blok içeriğini döndürür. 2. writeBlock(i, b): i 3. placeBlock(b): endeksli blok üzerine b içeriğini yazar. Yeni bir endeks döndürür ve bu endeksli blok üzerine b içeriğini depolar. 4. freeBlock(i): i endeksli bloğu serbest bırakır. Bu, blok içeriği- nin artık kullanılmadığı anlamına gelir, bu nedenle, bu blok tarafından ayrılan dış bellek yeniden kullanılabilir. BlokDeposu’nu düşünmenin en kolay yolu, disk üzerinde her biri B bayt içeren bloklara bölünen bir dosyayı depolamanın tasarımlanmasıdır. Bu şekilde, readBlock(i) ve writeBlock(i, b), bu dosyadan sadece iB,...,(i + 1)B – 1 bayt okur ve üzerine yazar. Buna ek olarak, BlokDeposu, kullanıma hazır olan blokların bir serbest listesini tutabilir. freeBlock(i) tarafından serbest bırakılan bloklar, serbest listesine eklenir. Bu şekilde, placeBlock(b), serbest listesinden bir | 461 blok kullanabilir, veya hiçbiri hazır kullanılışlı değilse, dosyanın sonuna yeni bir blok ekler. 462| B-Ağaçları Bu bölümde, dış bellek modelinde verimliliği olan ve B-Ağaç denilen, İkili Ağaç’ların bir genellemesini tartışıyoruz. B-Ağaç, alternatif olarak, 2-4 Ağacı Bölümü’nde anlatılan 2-4 Ağaç’larının doğal genellemesi olarak görülebilir (2-4 Ağaç, B = 2 olarak belirlenmiş B-Ağacı’nın özel bir durumudur). Herhangi bir tamsayı, B ≥ 2 için B-Ağacı, yaprakları aynı derinliğe sahip olan, ve kök-olmayan her, u, iç düğümünün en az B çocuğu, ve en çok 2B çocuğunun olduğu bir ağaçtır. u çocukları, u.children dizisinde depolanır. Gerekli çocuk sayısı kökte dikkate alınmaz, 2 ve 2B aralığında herhangi bir sayıda olabilir. B-Ağacı’nın yüksekliği h ise, o zaman B-Ağacı’nın yaprak sayısı, l, için şu söylenebilir: İlk eşitsizliğin logaritması alınarak ve terimler yeniden düzenlenerek, elde edilir. | 463 Yani, B-Ağacı’nın yüksekliği, yaprak sayısının B-tabanında logaritması ile orantılıdır. B-Ağacı’nın her u düğümü, u.keys[0],...,u.keys[2B – 1] konumla- rında bir anahtar dizisi depolar. u, k çocuklu bir iç düğüm ise, o zaman u tarafından depolanan anahtarların sayısı tam olarak k – 1 olur, ve bunlar, u.keys[0],...,u.keys[k – 2] konumlarında depolanır. u.keys dizisinin kalan 2B – k + 1 girişleri null olarak belirlenir. u kök olmayan bir yaprak düğüm ise, o zaman, u, B – 1 ve 2B – 1 arasında bir anahtar değer depolar. B-Ağacı’nın anahtarları İkili Arama Ağacı’nın anahtarlarının benzeridir. k – 1 anahtar depolayan her, u düğümü için, sıralaması geçerlidir. Eğer, u bir iç düğüm ise, o zaman her i u.keys[i] {0,…,k – 2} için anahtarı, u.children[i] kökenli altağaçta depolanan her anahtardan büyüktür, ancak u.children[i + 1] kökenli altağaçta depolanan her anahtardan küçüktür. Yani, Şekil 14.2, B = 2 olan B-Ağacı’na bir örnek gösteriyor. 464| B-Ağacı’nda bir düğümde depolanan veri boyutu daha önce O(B) olarak açıklanmıştı. Dikkat edin ki, B-Ağacı’nın içindeki B değerini seçerken, bir düğüm bir adet dış bellek bloğuna sığmalıdır. Dış bellek modelinde, B-Ağaç işlemini gerçekleştirmek için gerekli zaman, erişilen (okunan veya yazılan) düğüm sayısı ile orantılıdır. Örneğin, anahtarlar 4 bayt tamsayı ve düğüm işaretleri de 4 bayt ise, o zaman B = 256 belirlemesiyle her düğümde, bayt veri depolanır. Blok boyutu 4096 bayt olan sabit disk veya bu bölümde tartışılan katı hal sürücüsü için bu, mükemmel bir B değeri olacaktır. B-Ağacı’nı uygulayan B-Ağaç sınıfı, B-Ağacı’nın düğümlerini ve kök düğümün endeksini, ri, depolayan BlokDeposu’nu, bs, depolar. | 465 Her zamanki gibi, veri yapısındaki eleman sayısını belirlemek için, n tamsayısı, kullanılır: 466| Arama İkili Arama Ağacı’ndaki bul(x) işlemini genelleştirerek Şekil 14.3’te gösterilen bul(x) işlemini uygulayabilirsiniz. x için arama kökte başlar, ve bir u düğümünün çocuklarının hangisinden arama devam edecekse bunu belirlemelisiniz. Bunun için, u düğümünde depolanan anahtarları kullanın. Daha spesifik olursak, bir u düğümündeki arama için, x’in u.keys içinde saklı olduğunu kontrol etmelisiniz. Eğer öyleyse, x bulunmuştur ve arama tamamlanır. Aksi takdirde, arama u.keys[i] > x olan en küçük, i, tamsayısını bulur, ve u.children[i] kökenli altağaçta arama devam eder. u.keys içinde bulunan hiçbir anahtar, x’den büyük değilse, o zaman arama u’nun en sağındaki çocuğundan devam eder. | 467 Aynı ikili arama ağaçlarında olduğu gibi, algoritma x’den büyük olan, en son görülen z anahtarını izler. x bulunmazsa, x’e eşit, veya daha fazla olan en küçük değer olarak, z, döndürülür. bul(x) işleminin merkezinde, null ile başlatılmış sıralı bir, a dizisi içinde x değerini arayan, findIt(a, x) işlemi bulunmaktadır. Bu işlem Şekil 14.4’de gösterilmiştir. Herhangi bir, a dizisi için, sıralı olarak dizilmiş anahtarlar a[0],...,a[k – 1] ile gösterildiği takdirde, ve başlangıçta a[k],...,a[a.length – 1] değerlerinin tümü null iken, örnek çalıştı- rılmıştır. Eğer x, dizide, i konumunda ise, o zaman findIt(a, x) tarafından döndürülen değer, – i – 1 olarak hesaplanır. Aksi takdirde, a[i] x, veya a[i] = null olan en küçük, i endeksini döndürür. 468| findIt(a, x) işlemi, her adımda arama alanını yarıya bölen ikili aramayı kullanır, bu nedenle O(log(a.length)) zamanda çalışır. Bizim ortamımızda, a.length = 2B olduğu için, findIt(a, x) çalışma zamanı O(log B) olur. B-Ağaç bul(x) işleminin çalışma zamanını, hem normal sözcük- RAM modelinde (her komutu hesaba kattığımız), ve hem dış bellek modelinde (sadece erişilen düğüm sayısını önemsediğimiz) analiz edebiliriz. B-Ağaç içindeki her yaprak en az bir anahtar depoladığı için, ve l yapraklı B-Ağaç’ın yüksekliği O(logB l) olduğu için, n anahtar depolayan B-ağacı’nın yüksekliği O(logB n) olarak hesaplanır. Bu nedenle, dış bellek modelinde, bul(x) işlemi O(logB n) zamanda çalışır. Sözcük-RAM modelinde çalışma zamanını belirlerken, eriş- | 469 tiğimiz her düğüm için, findIt(a, x) çağrı maliyetini hesaba katmalıyız, böylece sözcük-RAM modelinde bul(x) işlemi, zamanda çalışır. 470| Ekleme B-Ağacı ve Serbest Yükseklikli İkili Arama Ağacı Bölümü’nde anlatılan İkili Arama Ağacı veri yapısı arasındaki önemli farklardan biri, B-Ağaç düğümlerinin menşeilerine işaretçi tutmamalarıdır. Bunun nedeni kısaca açıklanacaktır. Menşei işaretçilerinin eksikliği B-Ağaç’lar üzerinde ekle(x) ve sil(x) işlemlerinin en kolayca özyi- neleme kullanılarak uygulanması anlamına gelir. B-Ağacı’nda ekle(x) çalışması sırasında düğümlerin bölünmesi ile bir tür dengeleme gereklidir. Tüm dengeli arama ağaçlarında olduğu gibi, bölünme iki düzeyli özyineleme sırasında gerçekleşir; bkz. Şekil 14.5. Bölünmeyi en iyi şu şekilde anlayabilirsiniz: 2B anahtar ve 2B + 1 çocuk sahibi bir, u düğümünü girdi olarak alan bir işlemdir. u.children[B],..,u.children[2B] benimsenerek yeni bir, w düğümü oluşturulur. Yeni düğüm w, u’nun en büyük anahtarlarını u.keys[B],…,u.keys[2B – 1] alır. Bu noktada, u, B çocuğa ve B anahtara sahiptir. Ekstra anahtar, u.keys[B – 1], u menşeine kadar geçirilerek, w benimsenir. Dikkat etmelisiniz ki, bölme işlemi üç düğüm değiştirir: u, u’nun menşei ve yeni düğüm w. B-ağaç düğümlerinin menşei işaretçilerini tutmamasının önemli nedeni, dış bellek erişimlerinin sayısını 3’ten B + 4’e artırmasıdır. w tarafından benimsenen B + 1 çocuğun tüm menşei işaretçilerini değiştirmek, büyük B değerleri için, BAğaç’larını çok daha az etkili kılar. | 471 Şekil 14.6, B-ağaç ekle(x) işleminin örnek çalıştırmasını gösteriyor. Yüksek seviyede bu işlem, x değerini eklemek için bir, u yaprağını bulur. Bunun sonucunda, B – 1 anahtar içerdiği için, u fazla doluyken, u bölünür. u’nun menşei fazla doluluk içindeyse, o zaman u menşei de bölünür, u’nun büyükbabasının fazla doluluk içermesine neden olabilir, vb. Bu süreç, ağaç her seferinde bir seviye yukarı hareket ederek, fazla dolu olmayan bir düğüme ulaşana kadar veya kök bölünene kadar devam eder. İlk durumda, işlem durur. Sonraki durumda, orijinal kök bölündüğü zaman elde edilen 472| düğümlerin kökün iki çocuğu haline gelmesiyle, yeni bir kök oluşturulur. ekle(x) işleminin kısa özeti, kökten yaprağa x aranır, bulunan yap- rağa x eklenir, ve sonra köke dönüş yolunda karşılaşılan herhangi fazla dolu düğümler bölünür. Geliştirdiğimiz bu üst düzey düşünceyle, bu işlemin özyinelemeli olarak nasıl uygulanabilir olduğunu araştırmaya devam ediyoruz. | 473 ekle(x) için gerekli gerçek iş, ui tanımlayıcısına sahip u kökenli altağaca x değerini ekleyen, addRecursive(x, ui) işlemi tarafından yapılıyor. u bir yaprak ise, o zaman x sadece u.keys içine eklenir. Aksi takdirde, özyinelemeli olarak x, uygun u’ çocuğu içine eklenir. Bu özyinelemeli çağrının sonucu, normalde null iken, aynı zamanda u’ bölündüğü için yeni oluşturulan, w, düğümüne bir referans olabilir. Bu durumda, w, u tarafından benimsenir ve ilk anahtarı alarak u’ üzerindeki bölme işlemini tamamlar. x değeri (u veya altındaki düğümlerden biri içine) eklendikten son- ra, addRecursive(x, ui) işlemi, u tarafından çok fazla anahtar depolanıp depolanmadığını (2B – 1 anahtardan daha fazla olmamalı) kontrol eder. Eğer öyleyse, u.split() işlemine yapılan bir çağrı ile u bölünür. u.split() çağrısının sonucu, addRecursive(x, ui) için dönüş değeri olarak kullanılan yeni bir düğümdür. 474| addRecursive(x, ui) işlemi, B-Ağacı’nın köküne bir, x değeri ekle- mek için addRecursive(x, ri) çağrısının yapıldığı, ekle(x) işlemini çalıştırır. addRecursive(x, ri), kökü bölene kadar giderse, o zaman hem eski kökü, ve hem eski kökün bölünmesiyle oluşturulan yeni düğümü çocukları olarak alan, yeni bir kök oluşturulur. ekle(x) ve addRecursive(x, ui) işlemlerini iki aşamada analiz ede- biliriz: Aşağı yönde: Özyinelemenin aşağı yönünde, x eklenmeden önce, bir dizi BAğacı düğümüne erişim sağlanır, ve her düğüm üzerinde findIt(a, x) çağrısı gerçekleştirilir. bul(x) işleminde olduğu gibi, | 475 dış bellek modelinde O(logB n) zamanda, ve sözcük-RAM modelinde O(log n) zamanda çalışır. Yukarı yönde: Özyinelemenin yukarı yönünde, x eklendikten sonra, bu işlemler, en fazla O(logB n) bölünme gerçekleştirir. Her bölünme sadece üç düğüm içerir, bu nedenle bu aşama dış bellek modelinde O(logB n) zamanda çalışır. Ancak, her bölünme B anahtarın ve çocuklarının bir düğümden diğer düğüme hareket etmesini içerdiği için, sözcük-RAM modelinde, O(B log n) zaman alır. B değeri oldukça büyük, hatta log n’den çok daha büyük olduğu takdirde, sözcük-RAM modelinde, B-ağacı’na bir değer eklemek, dengeli İkili Arama Ağacı içine eklemekten çok daha yavaş olabilir. Daha sonra, B-Ağaç’ların Amortize Analizi Bölümü’nde, durumun fazla da korkutucu olmadığını göstereceğiz; bir ekle(x) çalışması sırasında bölünme işlemlerinin amortize sayısı sabittir. SözcükRAM modelinde, ekle(x) işleminin (amortize) çalışma zamanı, bu nedenle, O(B + log n) olur. 476| Silme B-ağaç içindeki sil(x) işlemini uygulamak, yine en kolay şekilde, bir özyinelemeli işlemdir. Karmaşıklığı, birkaç işlem üzerinden yayılmasına rağmen, Şekil 14.7’de gösterilen genel süreç, oldukça kolaydır. Anahtarların karıştırılıp değiştirilmesiyle silme işlemi, bir x’ değerinin bazı, u yaprağından çıkarılması problemine indirgenir. x’ çıkarılmasıyla, u, B – 1 anahtar ile bırakılabilir, bu durum alttaşma olarak adlandırılır. Bir alttaşma oluştuğunda, u kardeşlerinden biri ile birleşir, veya kardeşinden anahtar ödünç alır. u, kardeşi ile birleştiyse, o zaman, u menşei, bir çocuk daha az, ve bir anahtar daha az sahibi olacaktır; bu, u’nun menşeinin de alttaşmasına neden olabilir, bu tekrar, ödünç alma veya birleştirerek düzeltilir, ancak birleştirme u'nun büyükbabasının da alttaşmasına neden olabilir. Bu süreç, köke kadar artık alttaşma kalmayana kadar, veya kökün son iki çocuğu bir tek çocuk halinde birleştirilene kadar geri dönüş yolunda çalışır. İkinci durum olduğunda, kök kaldırılır, ve yalnız olan tek çocuk yeni kök olarak hesaplanır. Şimdi, bu adımların her birinin nasıl uygulandığını detaylarıyla anlatacağız. sil(x) işleminin ilk işi, çıkarılacak x elemanını bulmaktır. x bir yaprakta bulunursa, o zaman bu yapraktan x silinir. Aksi takdirde, bazı iç düğüm, u için u.keys[i] pozisyonunda x bulunur- | 477 sa, o zaman algoritma u.children[i + 1] kökenli altağaçtaki en küçük, x’ değerini siler. x’ değeri, BAğaç’ta depolanan x’den büyük olan en küçük değerdir. x’ değeri, sonra u.keys[i] içindeki x değerini değiştirmek için kul- lanılacak. Şekil 14.8 bu süreci gösteriyor. removeRecursive(x, ui) bir uygulamasıdır: işlemi önceki algoritmanın özyinelemeli 478| Unutmayın ki, özyinelemeli olarak u’nun i’nci çocuğundan x değerini çıkardıktan sonra, bu çocuğun hala en az B – 1 anahtarı bulunduğunu removeRecursive(x, ui) işleminin sağlaması gerekiyor. Önceki kodda, u’nun i’nci çocuğunda bir alttaşma olup olmadığını kontrol ettik, ve bunu düzelten checkUnderflow(x, i) adı verilen bir işlemi kullandık. u’nun i’nci çocuğu w olsun. w sadece B – 2 anahtara sahipse, bunun düzeltilmesi gerekir. Düzeltme, w’nin bir kardeşinin kullanılmasını gerektirir. Bu u’nun ya (i + 1)’nci çocuğudur veya (i – 1)’nci çocuğudur. Genellikle, w’nin doğrudan solundaki kardeşi, v olan (i – 1)’nci çocuğu kullanacağız. Bunun işe yaramadığı sadece bir zaman vardır, i = 0 iken, bu durumda w’nin doğrudan sağındaki kardeşi kullanırız. | 479 480| Aşağıda, durumuna odaklanıyoruz. Burada u’nun i’nci çocu- ğundaki herhangi bir alttaşma, u’nun (i – 1)’nci çocuğu yardımı ile düzeltiliyor. i = 0 durumu da benzerdir, ve ayrıntıları ekteki kaynak kodunda bulunabilir. w düğümündeki bir alttaşmayı düzeltmek için, w için daha fazla anahtar (ve muhtemelen de çocuklar) bulmamız gerekiyor. Bunu yapmanın iki yolu vardır: | 481 Ödünç alma: w’nin, B – 1 anahtardan daha fazlasına sahip olan, v, adında bir kardeşi varsa, o zaman w bazı anahtarları (ve muhtemelen de çocukları) v’den ödünç alabilir. Daha spesifik olarak, v, size(v) tane anahtar depoluyorsa o zaman, v ve w, aralarında, anahtara sahip olur. Bu nedenle, v’den w’ye anahtarları kaydırabiliriz, böylece v ve w’nin her biri en az B – 1 anahtara sahip olacaktır. Şekil 14.9 bu süreci gösteriyor. Birleştirme: Eğer v’nin sadece B – 1 anahtarı varsa, daha zorlayıcı bir şey yapmamız gerekir, çünkü v herhangi bir anahtarı w’ye vermeyi göze alamaz. Bu nedenle, Şekil 14.10’de gösterildiği gibi, v ve w birleştirilir. Birleştirme işlemi bölme işleminin tersidir. 2B – 3 toplam anahtar içeren iki düğüm alır, ve onları 2B – 2 anahtar içeren tek bir düğüm haline birleştirir (Ek anahtarın gelmesinin nedeni şudur: v ve w’yi birleştirdiğimizde, onların ortak menşei u’nun şimdi bir daha az çocuğu vardır ve dolayısıyla anahtarlarından birisinden vazgeçmesi gerekiyor). Özetlemek gerekirse, B-Ağaç’taki sil(x) işlemi kökten yaprağa bir yol izler, u, yaprağından bir x’ anahtarını kaldırır, ve sonra u ve onun atalarını içeren sıfır veya daha fazla birleştirme işlemleri gerçekleştirir, ve en fazla bir ödünç alma işlemi gerçekleştirir. Her birleştirme ve ödünç alma işlemi sadece üç düğüm değiştirmeyi 482| içerdiğinden ve bu işlemlerin sadece O(logB n) kadarı oluştuğundan, dış bellek modelinde tüm süreç O(logB n) zamanda çalışır. Yine, sözcük-RAM modelinde her birleştirme ve ödünç alma işlemi, O(B) zamanda; sil(x) işlemi O(B logB n) zamanda çalışır. | 483 484| B-Ağaç’ların Amortize Analizi Şimdiye kadar göstermiştik ki: 1. Dış bellek modelinde, B-Ağaç’ın bul(x), ekle(x) ve sil(x) işlemlerinin çalışma zamanı O(logB n) olarak hesaplanır. 2. Sözcük-RAM modelinde, bul(x) işleminin çalışma zamanı O(log n), ve ekle(x), sil(x) işleminin çalışma zamanı O(B log n) olarak hesaplanır. Aşağıdaki önerme gösteriyor ki, şimdiye kadar, B-Ağaç’ları tarafından gerçekleştirilen birleştirme ve bölünme işlemlerinin sayısını, olduğundan fazla tahmin ettik. Önerme 14.1. Boş bir B-Ağaç ile başlandığında, m adet ekle(x) ve sil(x) işlemi herhangi bir sırada yürütülürse, en çok 3m/2 adet bölünme, birleştirme ve ödünç alma gerçekleştirilir. Kanıt. Bunun kanıtı, zaten Kırmızı Siyah Ağaçlar-Özet Bölümü’nde, B = 2 özel durumu için kısaca anlatılmıştı. Önerme, kredi düzeni kullanılarak kanıtlanabilir. Burada, 1. Her bölme, birleştirme, veya ödünç alma işlemi iki kredi ile ödenir, yani, bu işlemlerin biri oluştuğunda her zaman bir kredi kaldırılır; ve, 2. Herhangi ekle(x) veya sil(x) işlemi sırasında en çok üç kredi oluşturulur. | 485 Herhangi bir zamanda, en çok 3m kredi oluşturulduğu için, ve her bir bölünme, birleştirme ve ödünç alma iki kredi ile ödendiği için en çok 3m/2 adet bölünme, birleştirme, ve ödünç alma yapıldığı sonucuna varırız. Bu krediler, Şekil 14.5, 14.9 ve 14.10’da ¢ sembolü kullanılarak gösterilmiştir. Bu kredileri takip etmek için, kanıt, aşağıdaki kredi değişmeyenini korur: B – 1 anahtara sahip kök-olmayan bir düğüm, bir kredi depolar, ve 2B – 1 anahtarlı herhangi bir düğüm üç kredi depolar. En az B anahtar ve en çok 2B – 2 anahtar depolayan bir düğümün herhangi bir kredi depolaması gerekmez. Geriye kalan yapmamız gereken, kredi değişmeyenini korumak olduğunu göstermek ve her ekle(x) ve sil(x) işlemi sırasında, yukarıda verilen, 1. ve 2. özellik- leri sağlamaktır. Ekleme: ekle(x) işlemi, herhangi bir birleştirme veya ödünç alma gerçekleştirmez, bu nedenle, sadece ekle(x) için yapılan aramaların bir sonucu olarak ortaya çıkan bölünme işlemlerini dikkate almamız gerekiyor. Her bölünme işlemi gerçekleştiğinde, zaten 2B – 1 anahtar içeren bir, u düğümüne bir anahtar eklenir. Bu durumda, u, B – 1 anahtar içeren u’, ve B anahtar içeren u’’ düğümü olmak üzere iki düğüme ayrılmıştır. Bu işlem öncesinde, u, 2B – 1 anahtar ve dolayısıyla üç kredi saklıyordu. Bu kredilerin ikisi, bölünmeyi ödemek için kullanılabilir, ve diğer kredi, kredi değişmeyenini korumak için (B – 1 486| anahtara sahip olan) u’ düğümüne verilebilir. Bu nedenle, bölünme için ödeme yapabiliriz, ve herhangi bir bölünme sırasında kredi değişmeyenini koruyabiliriz. Bir ekle(x) işlemi sırasında meydana gelen düğümler için yapılan diğer değişiklik, sadece bütün bölünmeler tamamlandığında gerçekleşir. Bu değişiklik, bazı u’ düğümüne yeni bir anahtar eklenmesini içerir. Eğer, bunun öncesinde u’ düğümünün 2B – 2 çocuğu vardıysa, şimdi 2B – 1 çocuk sahibidir ve bu nedenle üç kredi almak zorundadır. Bu ekle(x) işlemi ile dağıtılan yalnız ve tek kredidir. Silme: sil(x) için yapılan bir çağrı sırasında, sıfır veya daha fazla birleştirme meydana gelir, ve muhtemelen bunu tek bir ödünç alma izler. Her birleştirme, sil(x) çağrısı öncesinde her biri tam olarak B –1 anahtar sahibi iki düğümün, v ve w, tam olarak 2B – 2 anahta- ra sahip tek bir düğüm halinde birleştirilmesi nedeniyle oluşur. Bu türde her birleştirme, bu nedenle, birleştirmeyi ödemek için kullanılabilecek olan iki krediyi serbest bırakır. Herhangi bir birleştirme yapıldıktan sonra, en fazla bir ödünç alma işlemi gerçekleşir; daha sonra başka hiçbir birleştirme, veya ödünç alma meydana gelmez. Bu ödünç alma işlemi, sadece B – 1 anahtara sahip, v, yaprağından bir anahtarı kaldırırsak oluşur. v düğümü bu nedenle bir krediye sahiptir, ve bu kredi ödünç alma maliyetine doğru gider. Bu tek kredi ödünç almayı ödemek için yeterli değildir, bu nedenle ödemeyi tamamlamak için bir kredi yaratırız. | 487 Bu noktada, bir kredi yarattık ve hala kredi değişmeyeninin korunabilir olduğunu göstermemiz gerekiyor. En kötü durumda, v’nin kardeşi, w, ödünç almadan önce tam olarak B anahtara sahipti, böylece, daha sonra, v ve w, her ikisinin de B – 1 anahtarı olacaktır. Bunun anlamı, işlem tamamlandığında v ve w, her ikisinin de kredi depoluyor olması gerekir. Bu nedenle, bu durumda, v ve w’ye vermek için, ek iki kredi oluştururuz. Bir sil(x) çalışması sırasında, en fazla bir kez ödünç alma olduğu için bu, gerektiği gibi en çok üç kredi yarattığımız anlamına gelir. sil(x) işlemi ödünç alma işlemini içermiyorsa, bunun nedeni, iş- lemden önce B veya daha fazla anahtarı olan bazı düğümden bir anahtar çıkararak bitirdiği içindir. En kötü durumda, bu düğümün, tam olarak B anahtarı vardı, öyle ki şimdi B – 1 anahtarı bulunuyor, ve yarattığımız bir kredi verilmelidir. Her iki durumda – silme, ödünç alma ile işini bitirse de veya bitirmese de – sil(x) için yapılan bir çağrı sırasında kredi değişmeyenini korumak, ve meydana gelen tüm ödünç alma ve birleştirmelerin ödemesini yapmak için, en fazla üç kredi yaratılmalıdır. Bu önermenin kanıtını tamamlar. Önerme 14.1’in amacı, sözcük-RAM modelinde, m adet ekle(x) ve sil(x) işlemi sırasında gerçekleştirilen bölünme ve birleştirmelerin, sadece O(Bm) zamanda çalıştığını göstermektir. Yani, işlem başına amortize maliyet, sadece O(B) olarak hesaplanır, böylece sözcük- 488| RAM modelinde, ekle(x) ve sil(x) amortize maliyeti O(B + log n) olarak hesaplanır. Aşağıdaki teorem çifti bunu özetliyor: Teorem 14.1 (Dış Bellek B-Ağaç’ları). BAğaç, Sıralı Küme arayüzünü uygular. Dış Bellek modelinde, BAğaç, işlem başına O(logB n) zamanda çalışan ekle(x), sil(x), ve bul(x) işlemlerini destekler. Teorem 14.2 (Sözcük-RAM B-Ağaç’ları). BAğaç, Sıralı Küme arayüzünü uygular. Sözcük-RAM modelinde, bölünme, birleştirme ve ödünç almaların maliyeti önemsenmediği takdirde, BAğaç, işlem başına O(log n) zamanda çalışan ekle(x), sil(x), ve bul(x) işlemlerini destekler. Boş bir BAğaç ile başlandığında, herhangi bir sırada m adet ekle(x) ve sil(x) işlemlerini yürütürsek bölünme, birleştir- me, ve ödünç alma, toplam O(Bm) zamanda çalışır. | 489 Tartışma ve Alıştırmalar I/O modeli veya disk erişimi modeli olarak da adlandırılan, dış bellek hesaplama modeli, Aggarwal ve Vitter tarafından tanıtıldı [4]. B-Ağacı için dış bellek araması, İkili Arama Ağacı için içsel bellek aramasına benzer. B-ağacı [9] 1970 yılında Bayer ve McCreight tarafından tanıtıldı, ve on yıldan daha az bir süre sonra, Comer ACM Bilgisayar Anketleri makalesi, onları her yerde hazır bulunan olarak anmıştır [15]. İkili Arama Ağacı B-Ağacı gibi, B-Ağacı’nın, B+ Ağacı, B* Ağacı, ve sayılan dahil olmak üzere birçok çeşidi vardır. B-Ağacı, gerçekten her yerde vardır, ve Apple'ın HFS+, Microsoft'un NTFS, ve Linux Ext4 dahil olmak üzere, birçok dosya sistemlerinde, her büyük veritabanı sisteminde, ve anahtar-değer depolayan bulut bilişimin birincil veri yapısıdır. Graefe’nin en son anketi [36] birçok modern uygulamalar, varyantları, ve B-ağacı’nın optimizasyonları üzerine 200+ sayfalık bakış sağlar. B-Ağacı, Sıralı Küme arayüzünü uygular. Yalnızca Sırasız Küme arayüzü gerekli ise, dış bellek karma işlemi, B-Ağacı’nın bir alternatifi olarak kullanılabilir. Dış bellek karma tasarımları vardır; bkz. örneğin, Jensen ve Pagh [43]. Bu tasarımlar, Sırasız Küme işlemlerini, dış bellek modelinde O(1) beklenen zamanda uygular. Bununla birlikte, çeşitli nedenlerden dolayı, birçok uygulama sadece Sıra- 490| sız Küme işlemlerini gerektiriyor olsa bile, B-Ağaç’larını hala kul- lanmaktadır. B-Ağaç’larını böyle popüler bir seçim yapan nedenlerden biri, ge- nellikle önerilen O(logB n) çalışma zamanı sınırlarından daha iyi performans gösteriyor olmasıdır. Bunun nedeni, dış bellek ortamlarında, B değeri genellikle oldukça büyüktür – yüzler hatta binler cinsinden. Bunun anlamı, B-Ağaç verilerinin % 99, hatta % 99,9 kadarı yapraklarda depolanır. Büyük bir belleğe sahip bir veritabanı sisteminde, B-ağacı’nın, RAM’deki tüm iç düğümlerini önbelleğe alması mümkün olabilir, çünkü toplam veri setinin sadece % 1 veya % 0,1 kadarını temsil eder. Bunun anlamı, B-ağacı’nın, RAM’i içinde iç düğümler aracılığıyla ve bunu takiben bir yaprak bulup getirmek için, tek bir dış bellek erişimiyle çok hızlı arama gerçekleştirebilmesidir. Alıştırma 14.1. Şekil 14.2’deki B-Ağacı’na 1,5 ve 7,5 anahtarlarını eklediğinizde ne olacağını gösterin. Alıştırma 14.2. Şekil 14.2’deki B-Ağacı’ndan 3 ve 4 anahtarlarını sildiğinizde ne olacağını gösterin. Alıştırma 14.3. n anahtar depolayan B-Ağacı’nın iç düğümlerinin maksimum sayısı nedir? (n ve B parametrelerini alan bir fonksiyon tanımlayın.) Alıştırma 14.4. Bu bölümün giriş kısmında, B-Ağacı’nın sadece, O(B + logB n) boyutunda içsel belleğe ihtiyacı olduğu öne sürül- | 491 müştü. Ancak, burada verilen uygulama gerçekte daha fazla bellek gerektiriyor. 1. Bu bölümde verilen ekle(x) ve sil(x) işlemlerinin uygula- masının, O(B logB n) ile orantılı içsel bellek kullandığını gösterin. 2. Bu işlemlerin bellek tüketimini O(B + logB n) düzeyine azaltmak amacıyla, nasıl değiştirebileceğinizi açıklayın. Alıştırma 14.5. Şekil 14.6 ve 14.7’deki ağaçlar üzerinde, Önerme 14.1’in kanıtında kullanılan kredileri yazın. Bölünme, birleştirme, ödünç alma ve kredi değişmezinin korunmasını üç ek kredi ile ödeyebileceğinizi doğrulayın. Alıştırma 14.6. Düğümleri B’den 3B’ye kadar çocuk (ve dolayısıyla B – 1’den 3B – 1’e kadar sayıda anahtar) sahibi olan B-Ağacı’nın değiştirilmiş bir versiyonunu tasarlayın. B-Ağacı’nın bu yeni versiyonunun, m işlem dizisi sırasında sadece O(m/B) bölünme, birleştirme ve ödünç alma gerçekleştirdiğini gösterin. Alıştırma 14.7. Bu alıştırmada, B-Ağaç’larında bir seferde en fazla üç düğümü dikkate alarak bölünme, ödünç alma ve birleştirme sayısını asimptotik olarak azaltan, ve değiştirilmiş bir bölünme ve birleştirme işlemi tasarlayacaksınız. 1. u fazla dolu bir düğüm ve, v, u’nun hemen sağındaki kardeş olsun. u taşmasını düzeltmek için iki yol vardır: 492| u anahtarlarından bazılarını v’ye verebilir; veya, u bölünebilir, ve u ve v anahtarları, u, v ve yeni oluşturulan w düğümü arasında eşit olarak dağıtılabilir. Bu işlem sonrasında etkilenen düğümlerin her birinin (en fazla 3 adet), herhangi bir sabit için, en az ve en çok anahtar sahibi olduğunu gösterin. 2. u az dolu bir düğüm, ve v ve w, u’nun kardeşleri olsun. u alttaşmasını düzeltmek için iki yol vardır: Anahtarlar, u, v ve w arasında dağıtılabilir; veya, u, v, ve w iki düğüm halinde birleştirilir, ve u, v ve w anah- tarları bu düğümler arasında dağıtılabilir. Bu işlem sonrasında etkilenen düğümlerin her birinin (en fazla 3 adet), herhangi bir sabiti için, en az ve en çok anahtar sahibi olduğunu gösterin. 3. m işlem sırasında, bu değişikliklerle gerçekleştirilen birleştirme, ödünç alma, ve bölünme sayısının O(m/B) olduğunu gösterin. Alıştırma 14.8. Şekil 14.11’de gösterilen B+-Ağacı, her bir anahtarı bir yaprakta tutar, ve yaprakları Çifte-Bağlantılı Liste olarak depolar. Her zamanki gibi, her yaprak B – 1 ve 2B – 1 arası bir sayıda anahtar depolar. Sonuncusu dışında, her yaprağın en büyük değerini depolayan B-Ağacı, bu listenin yukarısında yer alır. | 493 1. B+-Ağacı üzerinde, ekle(x), sil(x) ve bul(x) işlemlerinin hızlı uygulamalarını nasıl gerçekleştirebileceğinizi anlatın. 2. B+-Ağacı üzerinde x’ten daha büyük, ve y’den daha küçük ve- ya eşit tüm değerleri bildiren findRange(x, y) işlemini verimli olarak nasıl uygulayabileceğinizi açıklayın. 3. bul(x), ekle(x), sil(x) ve findRange(x, y) işlemlerini gerçek- leştiren BPlusTree sınıfını uygulayın. 4. B+-Ağacı, bazı anahtarları çoğaltır, çünkü hem B-Ağacı’nda, hem listede, her ikisinde de depolanır. B’nin büyük değerleri için anahtar çoğaltılmasının neden çok fazla pahalı olmadığını açıklayın. SON 494| | 495 Kaynakça (Bibliography) [1] Free eBooks by Project Gutenberg. Available from: http://www.gutenberg.org/ [cited 2011-10-12]. [2] IEEE Standard for Floating-Point Arithmetic. Technical report, Microprocessor Standards Committee of the IEEE Computer Society, 3 Park Avenue, New York, NY 10016-5997, USA, August 2008. doi:10.1109/IEEESTD.2008.4610935. [3] G. Adelson-Velskii and E. Landis. An algorithm for the organization of information. Soviet Mathematics Doklady, 3(1259-1262):4, 1962. [4] A. Aggarwal and J. S. Vitter. The input/output complexity of sorting and related problems. Communications of the ACM, 31(9):1116–1127, 1988. [5] A. Andersson. Improving partial rebuilding by using simple balance criteria. In F. K. H. A. Dehne, J.-R. Sack, and N. Santoro, editors, Algorithms and Data Structures, Workshop WADS ’89, Ottawa, Canada, August 17–19, 1989, Proceedings, volume 382 of Lecture Notes in Computer Science, pages 393–402. Springer, 1989. [6] A. Andersson. Balanced search trees made simple. In F. K. H. A. Dehne, J.-R. Sack, N. Santoro, and S. Whitesides, editors, Algorithms and Data Structures, Third Workshop, WADS ’93, 496| Montreal, Canada, August 11–13, 1993, Proceedings, volume 709 of Lecture Notes in Computer Science, pages 60–71. Springer, 1993. [7] A. Andersson. General balanced trees. Journal of Algorithms, 30(1):1–18, 1999. [8] A. Bagchi, A. L. Buchsbaum, and M. T. Goodrich. Biased skip lists. In P. Bose and P. Morin, editors, Algorithms and Computation, 13th International Symposium, ISAAC 2002 Vancouver, BC, Canada, November 21–23, 2002, Proceedings, volume 2518 of Lecture Notes in Computer Science, pages 1–13. Springer, 2002. [9] R. Bayer and E. M. McCreight. Organization and maintenance of large ordered indexes. In SIGFIDETWorkshop, pages 107–141. ACM, 1970. [10] Bibliography on hashing. Available from: http://liinwww.ira. uka.de/bibliography/Theory/hash.html [cited 2011-07-20]. [11] J. Black, S. Halevi, H. Krawczyk, T. Krovetz, and P. Rogaway. UMAC: Fast and secure message authentication. In M. J. Wiener, editor, Advances in Cryptology - CRYPTO ’99, 19th Annual International Cryptology Conference, Santa Barbara, California, USA, August 15–19, 1999, Proceedings, volume 1666 of Lecture Notes in Computer Science, pages 79–79. Springer, 1999. | 497 [12] P. Bose, K. Douieb, and S. Langerman. Dynamic optimality for skip lists and b-trees. In S.-H. Teng, editor, Proceedings of the Nineteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2008, San Francisco, California, USA, January 20–22, 2008, pages 1106– 1114. SIAM, 2008. [13] A. Brodnik, S. Carlsson, E. D. Demaine, J. I. Munro, and R. Sedgewick. Resizable arrays in optimal time and space. In Dehne et al. [18], pages 37–48. [14] J. Carter and M. Wegman. Universal classes of hash functions. Journal of computer and system sciences, 18(2):143–154, 1979. [15] D. Comer. The ubiquitous B-tree. ACM Computing Surveys, 11(2):121–137, 1979. [16] C. Crane. Linear lists and priority queues as balanced binary trees. Technical Report STAN-CS-72-259, Computer Science Department, Stanford University, 1972. [17] S. Crosby and D.Wallach. Denial of service via algorithmic complexity attacks. In Proceedings of the 12th USENIX Security Symposium, pages 29–44, 2003. [18] F. K. H. A. Dehne, A. Gupta, J.-R. Sack, and R. Tamassia, editors. Algorithms and Data Structures, 6th International Workshop, WADS ’99, Vancouver, British Columbia, Canada, August 11–14, 1999, Proceedings, volume 1663 of Lecture Notes in Computer Science. Springer, 1999. 498| [19] L. Devroye. Applications of the theory of records in the study of random trees. Acta Informatica, 26(1):123–130, 1988. [20] P. Dietz and J. Zhang. Lower bounds for monotonic list labeling. In J. R. Gilbert and R. G. Karlsson, editors, SWAT 90, 2nd Scandinavian Workshop on Algorithm Theory, Bergen, Norway, July 11–14, 1990, Proceedings, volume 447 of Lecture Notes in Computer Science, pages 173–180. Springer, 1990. [21] M. Dietzfelbinger. Universal hashing and k-wise independent random variables via integer arithmetic without primes. In C. Puech and R. Reischuk, editors, STACS 96, 13th Annual Symposium on Theoretical Aspects of Computer Science, Grenoble, France, February 22–24, 1996, Proceedings, volume 1046 of Lecture Notes in Computer Science, pages 567–580. Springer, 1996. [22] M. Dietzfelbinger, J. Gil, Y. Matias, and N. Pippenger. Polynomial hash functions are reliable. InW. Kuich, editor, Automata, Languages and Programming, 19th International Colloquium, ICALP92, Vienna, Austria, July 13–17, 1992, Proceedings, volume 623 of Lecture Notes in Computer Science, pages 235–246. Springer, 1992. [23] M. Dietzfelbinger, T. Hagerup, J. Katajainen, and M. Penttonen. A reliable randomized algorithm for the closest-pair problem. Journal of Algorithms, 25(1):19–51, 1997. | 499 [24] M. Dietzfelbinger, A. R. Karlin, K. Mehlhorn, F. M. auf der Heide, H. Rohnert, and R. E. Tarjan. Dynamic perfect hashing: Upper and lower bounds. SIAM J. Comput., 23(4):738–761, 1994. [25] A. Elmasry. Pairing heaps with O(loglogn) decrease cost. In Proceedings of the twentieth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 471–476. Society for Industrial and Applied Mathematics, 2009. [26] F. Ergun, S. C. Sahinalp, J. Sharp, and R. Sinha. Biased dictionaries with fast insert/deletes. In Proceedings of the thirty-third annual ACM symposium on Theory of computing, pages 483–491, New York, NY, USA, 2001. ACM. [27] M. Eytzinger. Thesaurus principum hac aetate in Europa viventium (Cologne). 1590. In commentaries, ‘Eytzinger’ may appear in variant forms, including: Aitsingeri, Aitsingero, Aitsingerum, Eyzingern. [28] R.W. Floyd. Algorithm 245: Treesort 3. Communications of the ACM, 7(12):701, 1964. [29] M. Fredman, R. Sedgewick, D. Sleator, and R. Tarjan. The pairing heap: A new form of self-adjusting heap. Algorithmica, 1(1):111–129, 1986. 500| [30] M. Fredman and R. Tarjan. Fibonacci heaps and their uses in improved network optimization algorithms. Journal of the ACM, 34(3):596–615, 1987. [31] M. L. Fredman, J. Komlos, and E. Szemeredi. Storing a sparse table with 0 (1) worst case access time. Journal of the ACM, 31(3):538–544, 1984. [32] M. L. Fredman and D. E. Willard. Surpassing the information theoretic bound with fusion trees. Journal of computer and system sciences, 47(3):424–436, 1993. [33] I. Galperin and R. Rivest. Scapegoat trees. In Proceedings of the fourth annual ACM-SIAM Symposium on Discrete algorithms, pages 165–174. Society for Industrial and Applied Mathematics, 1993. [34] A. Gambin and A. Malinowski. Randomized meldable priority queues. In SOFSEM98: Theory and Practice of Informatics, pages 344– 349. Springer, 1998. [35] M. T. Goodrich and J. G. Kloss. Tiered vectors: Efficient dynamic arrays for rank-based sequences. In Dehne et al. [18], pages 205–216. [36] G. Graefe. Modern b-tree techniques. Foundations and Trends in Databases, 3(4):203–402, 2010. [37] R. L. Graham, D. E. Knuth, and O. Patashnik. Concrete Mathematics. Addison-Wesley, 2nd edition, 1994. | 501 [38] L. Guibas and R. Sedgewick. A dichromatic framework for balanced trees. In 19th Annual Symposium on Foundations of Computer Science, Ann Arbor, Michigan, 16–18 October 1978, Proceedings, pages 8–21. IEEE Computer Society, 1978. [39] C. A. R. Hoare. Algorithm 64: Quicksort. Communications of the ACM, 4(7):321, 1961. [40] J. E. Hopcroft and R. E. Tarjan. Algorithm 447: Efficient algorithms for graph manipulation. Communications of the ACM, 16(6):372–378, 1973. [41] J. E. Hopcroft and R. E. Tarjan. Efficient planarity testing. Journal of the ACM, 21(4):549–568, 1974. [42] HP-UX process management white paper, version 1.3, 1997. Available from: http://h21007.www2.hp.com/portal/download/files/prot/files/STK/pdfs /proc_mgt.pdf [cited 2011-07-20]. [43] M. S. Jensen and R. Pagh. Optimality in external memory hashing. Algorithmica, 52(3):403–411, 2008. [44] P. Kirschenhofer, C. Martinez, and H. Prodinger. Analysis of an optimized search algorithm for skip lists. Theoretical Computer Science, 144:199–220, 1995. 502| [45] P. Kirschenhofer and H. Prodinger. The path length of random skip lists. Acta Informatica, 31:775–792, 1994. [46] D. Knuth. Fundamental Algorithms, volume 1 of The Art of Computer Programming. Addison-Wesley, third edition, 1997. [47] D. Knuth. Seminumerical Algorithms, volume 2 of The Art of Computer Programming. Addison-Wesley, third edition, 1997. [48] D. Knuth. Sorting and Searching, volume 3 of The Art of Computer Programming. Addison-Wesley, second edition, 1997. [49] C. Y. Lee. An algorithm for path connection and its applications. IRE Transaction on Electronic Computers, EC-10(3):346–365, 1961. [50] E. Lehman, F. T. Leighton, and A. R. Meyer. Mathematics for Computer Science. 2011. Available from: http://courses.csail.mit.edu/6.042/spring12/mcs.pdf [cited 2012-09- 06]. [51] C. Mart´ınez and S. Roura. Randomized binary search trees. Journal of the ACM, 45(2):288–323, 1998. [52] E. F. Moore. The shortest path through a maze. In Proceedings of the International Symposium on the Theory of Switching, pages 285–292, 1959. | 503 [53] J. I.Munro, T. Papadakis, and R. Sedgewick. Deterministic skip lists. In Proceedings of the third annual ACM-SIAM symposium on Discrete algorithms (SODA’92), pages 367–375, Philadelphia, PA, USA, 1992. Society for Industrial and Applied Mathematics. [54] Oracle. The Collections Framework. Available from: http://download.oracle.com/javase/1.5.0/docs/guide/collections/ [cited 2011-07-19]. [55] Oracle. Java Platform Standard Ed. 6. Available from: http://download.oracle.com/javase/6/docs/api/ [cited 2011-07- 19]. [56] Oracle. The Java Tutorials. Available from: http://download.oracle.com/javase/tutorial/ [cited 2011-07-19]. [57] R. Pagh and F. Rodler. Cuckoo hashing. Journal of Algorithms, 51(2):122–144, 2004. [58] T. Papadakis, J. I. Munro, and P. V. Poblete. Average search and update costs in skip lists. BIT, 32:316–332, 1992. [59] M. Patrascu and M. Thorup. Randomization does not help searching predecessors. In N. Bansal, K. Pruhs, and C. Stein, editors, Proceedings of the Eighteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2007, New Orleans, Louisiana, USA, January 7–9, 2007, pages 555–564. SIAM, 2007. 504| [60] M. Patrascu and M. Thorup. The power of simple tabulation hashing. Journal of the ACM, 59(3):14, 2012. [61] W. Pugh. A skip list cookbook. Technical report, Institute for Advanced Computer Studies, Department of Computer Science, University of Maryland, College Park, 1989. Available from: ftp://ftp.cs.umd.edu/pub/skipLists/cookbook.pdf [cited 2011-07- 20]. [62] W. Pugh. Skip lists: A probabilistic alternative to balanced trees. Communications of the ACM, 33(6):668–676, 1990. [63] Redis. Available from: http://redis.io/ [cited 2011-07-20]. [64] B. Reed. The height of a random binary search tree. Journal of the ACM, 50(3):306–332, 2003. [65] S. M. Ross. Probability Models for Computer Science. Academic Press, Inc., Orlando, FL, USA, 2001. [66] R. Sedgewick. Left-leaning red-black trees, September 2008. Available from: http://www.cs.princeton.edu/˜rs/talks/LLRB/LLRB.pdf [cited 2011-07-21]. [67] R. Seidel and C. Aragon. Randomized search trees. Algorithmica, 16(4):464–497, 1996. | 505 [68] H. H. Seward. Information sorting in the application of electronic digital computers to business operations. Master’s thesis, Massachusetts Institute of Technology, Digital Computer Laboratory, 1954. [69] Z. Shao, J. H. Reppy, and A. W. Appel. Unrolling lists. In Proceedings of the 1994 ACM conference LISP and Functional Programming (LFP’94), pages 185–195, New York, 1994. ACM. [70] P. Sinha. A memory-efficient doubly linked list. Linux Journal, 129, 2005. Available from: http://www.linuxjournal.com/article/6828 [cited 2013-06-05]. [71] SkipDB. Available from: http://dekorte.com/projects/opensource/SkipDB/ [cited 2011-07- 20]. [72] D. Sleator and R. Tarjan. Self-adjusting binary trees. In Proceedings of the 15th Annual ACM Symposium on Theory of Computing, 25– 27 April, 1983, Boston, Massachusetts, USA, pages 235–245. ACM, ACM, 1983. [73] S. P. Thompson. Calculus Made Easy. MacMillan, Toronto, 1914. Project Gutenberg EBook 33283. Available from: http://www.gutenberg.org/ebooks/33283 [cited 2012-06-14]. 506| [74] P. van Emde Boas. Preserving order in a forest in less than logarithmic time and linear space. Inf. Process. Lett., 6(3):80–82, 1977. [75] J. Vuillemin. A data structure for manipulating priority queues. Communications of the ACM, 21(4):309–315, 1978. [76] J. Vuillemin. A unifying look at data structures. Communications of the ACM, 23(4):229–239, 1980. [77] D. E.Willard. Log-logarithmic worst-case range queries are possible in space _(N). Inf. Process. Lett., 17(2):81–84, 1983. [78] J. Williams. Algorithm 232: Heapsort. Communications of the ACM, 7(6):347–348, 1964.
