Algoritmanın gayesi, bir metin içerisinde verilen bir dizginin (string) aranmasıdır. Literatürde arama yapılan metin için T (ingilizcedeki Text (metin) kelimesinden gelmektedir) ve aranan kelime için P (ingilizcedeki Pattern (örüntü) kelimesinden gelmektedir) kullanılmaktadır.

Klasik bir arama, yukarıdaki temsili resimde gösterilmiştir.

Algoritmanın diğer metin arama algoritmalarından en büyük farkı, aranan dizgi (pattern) yerine aranılan metin (text) üzerinden işlem yapmasıdır.

Yukarıdaki şekilde gösterildiği gibi, üzerinde arama işleminin yapıldığı metinde bulunan herhangi bir x harfi için, aranılan metin üzerindeki (pattern) en solda olan harf bulunmaya çalışılır.

arama işlemine başlanan α değerinin ardından gelen harfler eşleştiği sürece, aranan kelimenin (pattern) sonuna kadar eşleştikçe arama işlemi devam eder. Şayet bu aşama uyuşmayan bir harf olursa, zaten aranan kelimenin olmadığı sonucuna varılabilir.

Ardından uyuşma olup olmadığına bakılmaksızın aranan kelimeyi ß değerine denk gelecek şekilde kaydırma işlemi yapılır. Bu kaydırmanın olması için kelimenin (pattern) kalan kısmında ikinci bir değerinin bulunmaması gerekir.

Örnek

Algoritmanın çalışmasını bir örnek üzerinden göstermeye çalışalım.

Yukarıdaki şekilde görüldüğü üzere, aranan kelime için (P) sağdan sola doğru bir numaralandırma yapılmakta ve bu numaralandırma üzerinden aşağıda gösterilen HpBc dizisi çıkarılır. Bu dizi üzerinden metin üzerinde arama yapılır.

Sırasıyla önce, A harfi aranır. Ardından C ve G harfleri aranır. Dikkat edilirse, kelimede üç kere geçen A harfi, dizide bir kere kullanılmaktadır.

Uyuşma oldukça aranan kelime kaydırılmaktadır.

Müsvette Kod (Pseudo Code)

Algoritmanın müsvette kodu aşağıdaki şekilde yazılabilir:

Horspool (P = p₁p₂…p_m,T = t₁t₂…t_n)

Önişleme Aşaması

For c Î ∑ Do d[c] ← m

For j Î 1…m-1 Do d[p_j] ← m – j

Arama Aşaması

pos←0

While pos ≤ n-m Do

j ←m

While j > 0 And t_pos+j = p_j     Do j ← j-1

If j = 0 bulundu: pos+1

pos ← pos +d[t_pos+m]

End of while

Yukarıdaki algoritmada geçen değerlerin, örnek üzerindeki gösterimlerini adım adım anlatmaya çalışalım:

Yukarıdaki ilk adımda aranan ilk harf olan C harfi için öncelikle kümede olup olmadığı kontrolü yapılır. Bunun anlamı aranan kelimenin harflerinden birisi olmaması durumunda vakit kaybedilmemesidir.

İkinci adımda ise daha önce çıkardığımız HpBc[a] dizisine göre her harfin değerleri atanır.

Arama işleminin devamı aşağıdaki şekildedir:

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

     pos ← 0 + d[t₀₊₇] , pos ← 0 + d[A], pos ← 1

Yukarıda görüldüğü üzere, kelimenin ilk kontrolü için 1. pozisyonda bulunan A değeri aranmıştır. Ardından arama işlemi sonraki harf olan G için aşağıdaki şekilde devam eder:

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

pos ← 1 + d[t₁₊₇] , pos ← 1 + d[G], pos ← 3

G harfi ile C harfinin tutuşmamasından dolayı aranan kelime (P) kaydırılmıştır.

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

pos ← 3 + d[t₃₊₇] , pos ← 3 + d[G], pos ← 5

Benzer şekilde C ve G uyuşmamasından dolayı bir kere daha kaydırıyoruz.

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

While j > 0 And t_pos+j = p_j Do j ← j-1

If j = 0 pos+1′de bulundu

pos ← 5 + d[t₅₊₇] , pos ← 5 + d[G], pos ← 7

Görüldüğü üzere aranan kelime ile uyuşma oldu. Algoritmamızın ilgili satırlarını çalıştırıyor ve bulunduğunu rapor ediyoruz.

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

pos ← 7 + d[t₇₊₇] , pos ← 7 + d[A], pos ← 8

İkinci kere A harfini arıyoruz.

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

pos ← 8 + d[t₈₊₇] , pos ← 8 + d[T], pos ← 16

Bulunan A harfi G harfi ile uyuşmadığı için atlıyoruz:

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

pos ← 16 + d[t₁₆₊₇] , pos ← 16 + d[G], pos ← 18

pos > n-m // pos >23-7

while döngüsünden çık.

Son olarak kelimenin sonuna gelindiği halde aranan yazı bulunmadığı için algoritma sonlanıyor.

Algoritmanın Karmaşıklığı

Algoritmanın zaman karmaşıklığı aranan kelimenin boyu n ve aranılan kelimenin boyu m olmak üzere O(mn)’dir denilebilir. Çünkü en kötü durumda her aranılan kelime harfi için üzerinde arama yaptığımız her harfi karşılaştırmamız gerekebilir. Bu da her n harf için m adet karşılaştırmaya eşittir.

73 views

Bilgisayar bilimlerinin çeşitli alanlarında (örneğin yapay zeka, veri yapıları veya şekil kuramı (graph theory) gibi) kullanılan arama algoritmalarından birsidir.

Algoritma, derin öncelikli drama (depth first search) üzerine kurulu olduğu için, literatürde “iterative deepening depth first search (yinelemeli derinleşen, derin öncelikli arama)” olarak da geçmektedir.

Algoritma basitçe derinlik değerini bir değişkende tutmakta ve bu değeri her adımda arttırmaktadır.
Yineleme yapısı (iteration) basit bir döngü (loop) olarak düşünülebilir ve her adımda derinliğin, bir döngü değişkeni (loop variable) gibi düşünülerek derinleştiği kabul edilebilir.

Örneğin aşağıdaki şekli (graph) ele alalım:

Ağaçta görüldüğü üzere iki adet döngü (cycle) bulunmaktadır. Iterative Deepening search algoritmasını bu ağaç üzerinde çalıştıracak olursak, algoritma öncelikle derinlik değerini (bundan sonra d değişkeni (variable) ile ifade edilecektir) 0′dan başlatarak her adımda bir ilerletecektir.

d=0 için arama:
A
d=1 için arama:
A (tekrar A değerine bakar) B C (sanki ağacın en üstteki üç düğümü, şekilde gösterildiği gibi bağlanmış kabul edilebilir, daha alttaki derinliklerde bulunan DEFG düğümlerine hiç bakamaz)
d=2 için arama:
A B D E C F G (Bu aramada sanki sondaki daireler (cycle) bulunmuyormuş gibi kabul edilebilir, çünkü belirtilen derinlik bu dairelere kadar inemez)
d=3 için arama:
A B D B E C F G A
d=4 için arama:
A B D B D E B C F G A B C

Yukarıdaki arma işlemi, derinlik arttıkça devam etmektedir.

Arama algoritmalarının değerlendirildiği bazı kriterler bulunmaktadır. Buna göre IDDFS (iterative deepening depth first search) algoriması “tam” algoritma olarak kabul edilebilir.
Tamlık teriminin (completeness) anlamı aşağıdaki şekilde tanımlanabilir:

Bir arama algoritması, bütün düğümleri dolaşarak aranan düğümü bulmayı garanti ediyorsa bu algoritmaya tam arama algoritması ismi verilir.

Örneğin yine yukarıdaki şekil için klasik derin öncelikli arama (depth first search) algoritmasını ele alsaydık, bu algoritmanın tam olmadığını söyleyebilirdik. Bunun sebebi DFS algoritmasının dolaşması sırasında, aşağıdaki döngüye girmesidir:

A B D B D B D ( B D ikilisi sosuza kadar tekrar eder)

Kısacası A B D düğümleri dışındaki düğümlere asla bakmaz. Bu anlamda tam olmadığını söyleyebiliriz.

BFS (breadth first search , yayılma öncelikli veya sığ öncelikli arama) algoritması ise her zaman için tam kabul edilebilir, sebebi bir sonraki derinlik seviyesine inmeden önce, bulunduğu seviyedeki düğümleri bitirmesi ve bu sayede bütün ağaca bakmayı garanti etmesidir.

Algoritmanın karmaşıklığına değinecek olursak. Aşağıdaki şekilde bir formül ile karşılaşırız.

Bu formülde görülen terimler şekil kuramında (graph theory) sıkça kullanılan bazı değerlere atıfta bulunur.
d değerinin derinlik olduğunu daha önce belirtmiştik. b ile gösterilen değer ise dallanma katasyısıdır (branching factor).

Kısaca her düğümün kaç çocuğu olduğu (out order, kaç düğüme gidilebildiği) olarak tutulur. Örneğin tam dolu ikili arama ağacının (binary search tree) b değeri 2′dir. Genelde en kötü durum analizinde bütün çocukların dolu olması ihtimali üzerinde durulur. Ayrıca istatistiksel olarak ortalamam çocuk sayısının da alındığı olur. Örneğin şehirlerin tutulduğu bir şekilde, her şehirden gidilebilecek şehir sayısı değişmektedir. Bu durumda b değeri ortalama değer olarak hesaplanabilir.

Bu açıklama ardından yukarıdaki denkleme tekrar bakarak anlamaya çalışalım.

IDDFS algoritmasında, en altta bulunan düğümlerin 1 kere (d sabitlendiğinde en altta kalan düğümler hangileri ise) dolaşıldığını, d-1 derinliğindeki düğümlerin ise 2 kere dolaşıldığını ve böylece kök düğüme (root) kadar her düğümün, bulunduğu seviyeye göre kaç kere dolaşıldığını hesaplayabileceğimize göre yukarıdaki denklem çıkarılabilir.

Diğer bir deyişle d=0 için kök 1 kere dolaşılırken d=1 olduğunda kök 2 ve kökün çocukları 1 kere dolaşılmış olur. d=3 olduğunda kök 3 kere ve çocukları 2 ve en alttaki çocuklar ise 1 kere dolaşılmış olur. Görüldüğü üzere derinliğin her artışında kök derinlik kadar altındaki her düğüm ise birer azalarak en nihayetinde yapraklar (leaf) tek bir kere dolaşılmış olmaktadır.

Sonuç olarak Yukarıdaki formülün ilk terimi kök (d+1)1 (tek düğüm d+1 kere dolaşılmıştır) , ikinci terimi kökün çocukları (db (kökün çocukları (ki sayısı b’dir) derinlik kadar (ki d ile gösterilir) dolaşılmıştır).

Yukarıdaki bu formülü daha toplu şekilde aşağıda gösterildiği gibi yazabiliriz:

Algoritmanın dolaşma (arama) zamanı karmaşıklığı yukarıda gösterildiği gibidir. Terimler birleştirildiğinde en kötü durum analizi (worst case analysis) için O(b^d) gösterimi kullanılabilir.

Hafıza karmaşıklığı ise O(bd) olarak ifade edilebilir. Bunun sebebi d derinliğindeki bir ağacın her seviyesinde b adet çocuğu bulunması durumunda bd kadar düğüm olacağıdır. Algoritma, çalışması sırasında ilave düğümlere ihtiyaç duymaz ve şeklin kendisi üzerinde dolaşarak sonuca ulaşır.

387 views

Bu yazının amacı, geri izleme algoritmasının (backtracking algorithm) bir uygulaması olarak, basit bir labirentte yol bulma kodunu JAVA dilinde kodlamaktır. Bu uygulamada herhangi bir yapay zeka yönetmi uygulanmayacaktır. Basitçe kör arama (blind search) yapan ve ihtimalleri sırayla deneyen bir robot uygulaması geliştirilecektir.

Örneğin labirent bilgisinin bir dosyada bulunduğunu ve bizim amacımızın bu dosyayı okuyarak labirentin başlangıcından çıkışına kadar olan yolu bulmak olduğunu düşünelim. Labirent tasarımımızda duvarları 1 ve yolları 0 ile gösterelim. Örneğin aşağıda bir labirent verilmiştir:

1111111
0010011
1000011
1101111
1100000
1111111

Yukarıdaki bu labirentte, sol üst köşeyi başlangıç konumu ve sağ alt köşeyi de bitiş konumu olarak kabul edeceğiz. Buna göre labirentin her zaman için ikinci satırının ilk kolonunda başlıyoruz ve labirentin boyutuna göre son satırın bir üstünde en sağ kolonda bitiriyoruz. Amacımız bu iki nokta arasındaki yollardan bir tanesini çözüm olarak bulmak. Ayrıca dosyadan labirent okuyacağımız için, veri yapısı kullanımını kolaylaştırmak amacıyla, labirentin boyutlarını da dosyanın ilk satırında tutalım. Buna göre bir labirent dosyasının içeriği aşağıdaki şekilde olacaktır:

6 7
1111111
0010011
1000011
1101111
1100000
1111111

Dosyanın ilk satırında, labirentin satır ve sütun boyutları verilmiştir.

Algoritmamız, basitçe labirentin başlangıç konumundan yola çıkacak ve yol alternatiflerini değerlendirecektir. Şayet yol tek yönlü ise hareket etmeye devam edecek ancak bir yol ayrımına geldiğinde bu noktayı bir yığında (stack) tutarak çıkmaz bir yola girdiğinde en son aklında tuttuğu bu yola geri dönecek ve farklı bir karar verecektir.

Örneğin yukarıdkai problem için çözümü elle yaparak tasarımımıza başlayalım. Başlangıç durumumuz (1,0) olacak (dizide satır sayısının 0′dan başladığını düşünürsek, ikinci satırın ilk sütunu (1,0) olarak gösterilecektir.

Bitiş durumumuz ise (4,6) olarak belirlenecektir (dizi boyutumuzda azami satır ve sütun değerleri 5,6 olacaktır (boyuttan bir eksik) ve en altın bir üstü satır 4 ve son sütun 6 olacaktır. Dolayısıyla bitiş durumu olarak (4,6) tanımlıyoruz.

(1,0) konumundan, (4,6) konumuna kadar olan çözüm yolunu bulmak için adım adım algoritma tasarımımızı inceleylim.

Algoritmamız kör arama (blind search) olduğu için, çözüme giden en mantıklı yolu bulmak yerine bütün ihtimalleri deniyeceğiz. Bu ihtimalleri belirli bir sıra ile aramamız gerekiyor. Bu srıalama için algoritmamızı aşağıdaki şekilde tasarlayalım:

Geldiğim yeri işaretle

if(sola gidilmemişse)

sola git;

else if(sağa gidilmemişse

sağa git;

else if(yukarı gidilmemişse)

yukarı git;

else if (aşağı gidilmemişse)

aşağı git;

Yukarıdaki bu tasarımda sol -> sağ -> yukarı -> aşağı sırası tamamen rast gele olarak üretilmiştir ve daha farklı sırada da olabilirdi.

(1,0) konumundan başlayarak yukarıdaki algoritmayı icra ettirelim. İşaretleme için 2 değerini kullanacağız. Öncelikle yığın (stack) değeri boş olarak başlıyoruz (bundan sonra S olarak gösterilecek ve sağdan eklenerek sağdan çıkarma yapılacaktır):

1111111
0010011
1000011
1101111
1100000
1111111

S -> boş

İlk değeri işaretliyoruz:

1111111
2010011
1000011
1101111
1100000
1111111

(1,0) konumunda tek gidilebilecek komşu, (1,1) konumudur (1,0) konumunun komşuları 0,0 2,0 ve 1,1 olduğuan göre bu değerlere bakıyoruz ve bunlardan 0 olan tek değere gidiyoruz:

1111111
2210011
1000011
1101111
1100000
1111111

Benzer şekilde (1,1) konumunun tek 0 olan komşusu (2,1) olan konuma gidiliyor. Benzer şekilde (2,1) konumunun tek komşusu olan (2,2) konumuna gidilerek aşağıdaki durum elde ediliyor:

1111111
2210011
1220011
1101111
1100000
1111111

Yukarıdaki son durumda geldiğimiz konum (2,2) ve birden fazla komşumuzda 0 değer var. Yani (2,2) konumunun komşuları olan (2,3) ve (3,2) değerleri 0 olduğu için bu alternatiflerden birisini takip edeceğiz. İşte bu yol ayrımında yığın (stack) kullanmanın sırası geliyor. Bunun sebebi şu anda vereceğimiz kararın doğru olup olmadığını bilmediğimiz ve basitçe hata yapıyorsak buraya geri dönmek istememiz.

S -> (2,2)

Yukarıdaki şekilde karar noktamızı yığına yerleştirdikten (push) sonra algoritmamızdaki öncelikli yol olan sol tarafı deniyoruz. Sol tarafımızda ((2,2)’nin solunda (2,1) vardır) 0 olmadığı için gidemiyoruz. Algoritmamızdaki ikinci ihtimal olan sağ tarafa bakıyoruz (sağın koordinatı (2,3)) ve bu değer 0 olduğu için bu yönde gidiyoruz.

1111111
2210011
1222011
1101111
1100000
1111111

Sağa gitme işlemine devam ediyoruz (aşağıya gidemediğimiz için) ayrıca burada bir yol ayrımı bulunduğu için (sağa veya yukarıya gidebiliriz) yığının (stack) içerisine yerleştiriyoruz:

S -> (2,2) , (2,3)

1111111
2210011
1222211
1101111
1100000
1111111

Tek alternatif olan yukarıya devam ediyoruz:

1111111
2210211
1222211
1101111
1100000
1111111

Tek alternatif olan sola devam ediyoruz:

1111111
2212211
1222211
1101111
1100000
1111111

Netice itibariyle alternatifi kalmayan (hiçbir yönde 0 olmayan) bir duvar ile karşılaştık ve bu noktadan sonra çıkma ihtimalimiz kalmadığı için yığındaki en üstte bulunan ve en son karar verdiğimiz noktaya dönüyoruz.

Bu nokta (2,3) koordinatlarındadır ve pop edildikten sonra stack aşağıdaki şekildedir:

S – > (2,2)

Pop ettiğimiz (2,3) noktasında da gidilecek hiçbir alternatif bulunmuyor. Mecburen yığındaki (stack) bir sonraki noktaya dönüyoruz:

S -> Boş

Döndüğümüz koordinat (2,3) noktası ve buradaki tek alternatif aşağı yönde bulunan 0 değeri:

1111111
2212211
1222211
1121111
1100000
1111111

Bu aşamadan sonra, hiçbir alternatif kalmadan 0 olan yollar izlenerek sonuca ulaşan yol bulunmuş oluyor.

Kodlama

Yukarıdaki yaklaşımın JAVA dilinde kodlanmış hali yazının sonunda verilmiştir. Bu kodun kısaca açıklamasını bu bölümde anlatacağım. Kodumuzda temel olarak iki sınıf bulunuyor:

• currentInfo
• Maze

currentInfo sınıfı, anlık olarak matrisin hangi konumunda bulunduğumuzu tutmaya yarıyor. Çok basit şekilde satır ve sütün koordinatlarımızı barındırıyor. Ayrıca bu değerlere erişmeyi sağlayan inşa sınıfları (constructors) ve kapsülleme fonksiyonları (encapsulation) bulunuyor.

Maze sınıfı ise geri kalan herşeyi yapan ana sınıfımız. Bu sınıfta getMaze() isimli fonksiyon, dosyadan labirent bilgilerini okumak için kullanılıyor. solveMaze fonksiyonu da labirentteki sonucu bulmaya yarayan yukarıdaki işlemleri çalıştırıyor.

Yukarıdaki anlatımda geçen ve S harfi ile ifade ettiğimiz yığın (stack) ise kodumuzda path ismi ile tanımlanmış java.util.Stack sınıfından tanımlanmış bir yığın. Buradaki yığın, karar verirken atılan her adımı tutmakta. Yani yukarıdaki labirent çözümünde geçen ve 2 olarak işaretlerken, birden fazla 0 ihtimali bulunan dönüm noktalarını tutuyor.

Yığının en temel 3 fonksiyonu ise aşağıdaki şekildedir:

• Pop() yığında bulunan en üstteki değeri alarak bir değişkene döndürür.
• Push() yığının en üstüne, parametre olarak aldığı veriyi yerleştirir.
• Peek() yığının en üstündeki veriyi alır ancak pop fonksiyonunun aksine bu veriyi silmez. Bu fonksiyon bazı kaynaklarda Top() olarak da geçmektedir ancak java.util.Stack sınıfında peek ismi ile tanımlanmıştır.

Kodumuzda kullandığımız iki temel dizi ise aşağıda verilmiştir:

• mazeData[][] iki boyutlu bu dizi, dosyadan okunan ve hafızada labirent bilgisini tutan dizidir.
• Mark[][] diğer iki boyutlu dizimiz ise sonuca giden yolu tutar.

İkinci diziye neden ihtiyaç duyduğumuz sorusunu şu şekilde cevaplayalım. Dizimizi dolaşırken, yanlış yollara sapabiliyoruz, geçtiğimiz her yeri basarsak bu sonuçta görmek istediğimiz çözüm yolu olmayacaktır. Ayrıca labirentte dolaşırken, çözüme giden yolu 2 ile işaretliyoruz ama hatalı yolları da 2 ile işaretliyoruz. Dolayısıyla labirenti dolaştıktan sonra 2 ile işaretli yolları basarsak bu yollarda da sonuca gitmeyen değerlerin basılması söz konusu. Çözüm olarak ayrı bir dizide, sonuca giden yoldaki koordinatları ayrıca tutuyoruz.

Koddaki bazı satırları anlatmamız gerekirse:

Yukarıdaki kod parçasında, bulunduğumuz konumdan (current) sonraki gidebileceğimiz yönleri sırasıyla deniyoruz. İlk if koşulunda mazeData isimli dizide (yani labirentin verilerinin tutulduğu dizi) bulunan ve mevcut konumun bir sağında yer alan (col + 1 işleminin anlamı bir sonraki kolon demektir) değere gidilmesi ve bu değerin daha önce mark dizisinde işaretlenmemiş olması (gidilmemiş olması ) durumu kontrol edilmektedir. Ardından sırasıyla, sol, aşağı ve yukarı yönler için aynı kontroller yapılmaktadır. Yazıda anlatılan sıradan bu anlamda farklıdır.

Yukarıdaki kod parçasında ise, bir önceki kod parçasının devamı niteliğinde, şayet 4 yöndede hareket edilemiyorsa, çıkmaz bir yola girilmiş neticesine varılabilir. Bu durumda mevcut durum dolaşıldı anlamında, 2 ile işaretlendikten sonra, yığından (stack) pop fonksiyonu ile dönülecek en son karar anına bakılıyor.

Şayet yığın bir şekilde boş olursa (ki bu durum try/catch blokları arasında istisna kabz edilerek (exception handling) çözülmüştür) bu durumda labirentin bir çözümü olmadığını söyleyebiliriz çünkü hem bir çıkmaz yol bulduk hem de geriye döneceğimiz hiçbir yol ayrımı bulunmuyor demektir.

Netice itibariyle, 61. Satıra kadar ulaştıysak, bu satırda flag değişkeni true değerinde olup, yukarıdaki 4 iften birisine girerek bir yöne hareket etmiş olabilir. Bu durumda gidilen bu yok, mark dizisinde işaretlerenerek yığına yerleştiriliyor. Ayrıca flag değişkenin false olduğu tek ihtimal olan çıkmaz yol durumunda da if bloğu çalışmıyor.

Yukarıda alıntılıanan kod parçası ise bütün işlemler bitip, labirent bir sonuca ulaşacak şekilde dolaşıldıktan sonra, mark dizisi üzerinden dolaşılan yolu ekrana basmaktadır. Döngü, labirent boyutları olan dim1 ve dim2 sınırlarında dönmekte, her adımdaki konum 71. Satırda ekrana basılmakta ve sonraki konum da 4 farklı koşul konrolü ile işaretlenmiş olan yöne doğru değiştirilmektedir.

Kodun çalışması sonucunda, örnek ekran çıktısı aşağıda verilmiştir:

Görüldüğü üzere labirentteki bütün yolları dolaşarak, sonuca ulaşan yolları ekrana basmıştır(lütfen basma işlemi sırasında, 71. Satırda olduğu üzere önce satır sonra sütun koordinatının basıldığına dikkat ediniz). Bu örnek çalışma, aşağıdaki labirent içindir:

Ayrıca farklı bir dosya içeriği, projenin bulunduğu dizindeki maze.dat dosyasının içerisine yerleştirilerek çalıştırılabilir.

Kodun tamamını netbeans projesi olarak indirmek için tıklayınız.

932 views

Yazan : Şadi Evren ŞEKER

Literatürde tam arama veya etraflı arama olarak geçmektedir. İngilizcede “exhaustive search” terimi kullanılır. Genel olarak, arama algoritmalarının performansını arttırmak için kullanılan bir yöntemdir.

Bir arama algoritmasının tam arama (exhaustive search) olabilmesi için aşağıdaki şartları sağlaması gerekir:

• Bir değerin bulunmadığını söylemeden önce bütün değerlere bakmış veya bütün ihtimalleri değerlendirmiş olmalıdır.

• Arama uzayında hareket edilirken (Arama işlemi sırasında) sistematik bir yöntem kullanılmalıdır. Diğer bir deyişle arana değerlere tekrar tekrar bakılmamalı, ve her adımdan sonra hangi değere bakılacağı belirlenmelidir.

Yukarıdaki şartları sağlayan arama algoritmalarına etraflı arama veya tam arama ismi verilir. Ancak yukarıdaki ikinci maddenin bir istisnası bulunur. Bazı durumlarda arama algoritmasını hızlandırmak için rast gele bir değer ataması (randomness) kullanılabilir. Bu durum bir çelişki olarak görülmemelidir. Algoritmanın içerisinde bir rastgelelik bulunsa bile, aranan değerleri tekrar aramaması ve üretilecek olan rastgeleliğin tam kontrol altında tutulması halinde, arama algoritması etraflı arama olarak sınıflandırılabilir.

Etraflı arama algoritmalarını aynı zamanda birer geri izleme algoritması (back tracking algorithm) olarak isimlendirmek mümkündür. Aslında bütün etraflı arama algoritmaları (Exhaustive search algorithms) birer geri izleme algoritmasıdır (back tracking algorithm). Ancak bu cümlenin tersi doğru değildir. Yani bütün geri izleme algoritmalarının etraflı arama algoritması olduğunu söyleyemeyiz. Buradaki fark, etraflı arama algoritmalarının, arama işlemi sırasında aranacak olan değerlerin bir kısmını budamasından kaynaklanır (prunning). Yani bazı değerlerin bakılmasına gerek kalmayacak şekilde arama işlemini hızlandırırlar.

Bu anlamda doğrusal arama (linear search), kaba kuvvet araması (brute force algorithm) gibi temel arama algoritmaları birer etraflı arama kabul edilebilir.

294 views

Gelen bir soru üzerine, C dilinde bir dosyanın içeriğini tersten ekrana basan kodu yazıp sitede yayınlıyorum.

Öncelikle algoritmamızı inşa edelim.

Ters almak gibi işlemler yapı olarak özyineli (recursive) fonksiyonlara çok uygundur. Genelde stack (yığın) yapısının kullanıldığı özyineli fonksiyonlar bilgiyi tutma ve ters çevirme (son giren ilk çıkar (LIFO) algoritması) için elverişli olurlar. Bu yüzden biz de bir özyineli fonksiyon kullanarak dosyamızdan karakter karakter değerleri okuyacak sonra da bunları ekrana basacağız.

Kodu aşağıda veriyorum:

Kodumuzdaki main fonksiyonu sadece dosyayı açmakta ve sonra ters fonksiyonunu çağırmaktadır. Dosya ters fonksiyonunda işlendikten sonra (ki bu işleme dosyayı tersten basmak olacak) dosya kapatılmakta ve program sonlandırılmaktadır.

Gelelim ters fonksiyonuna. Bu fonksiyon, dosya göstericisini (file pointer) parametre olarak alıp, dosya sonu olup olmadığını kontrol ediyor. Feof fonksiyonu, şayet dosyanın sonuna ulaştıysa, return; satırını çalıştıracak ve dolayısıyla fonksiyondan çıkılacak. Aslında bu durum bizim dosyamızın sonu ve dolayısıyla fonksiyonumuzun sonu ve dolayısıyla özyineleme yığınımızın (recursion stack) sonu olmaktadır.

Fonksiyonun geri kalanında işlem gayet basit bir şekilde fscanf ile dosyadan okumak ve ardından tekrar ters fonksiyonunu çağırmak ve sonra da okunan karakteri ekrana basmak şekline ilerler.

Buradaki kritik nokta, ters fonksiyonunu, ekrana karakter basmadan çağırmaktır. Şayet kodun 11. ve 12. satırları yer değiştirecek olsaydı, yani önce ekrana basıp sonra ters fonksiyonunu çağıracak olsaydık, bu durumda dosyanın içeriği olduğu gibi ekrana basılacaktır. Biz bunun yerine o andaki okunan karakteri bekletiyoruz ve sonraki karakteri basması ve ters çevirmesi için yeniden fonksiyona veriyoruz. Bu işlem dosya sonuna kadar gidiyor. Nihayet dosya sonuna erişilince özyineli yığınımız (recursion stack) toparlanmaya başlıyor ve bu toparlanma sırasında ekrana karakterleri basarak ilerliyor.

Yukarıdaki kod, Dev-CPP ile test edilmiş ve çalışmaktadır. Örneğin girdi.txt dosyası olarak aşağıdaki içerikte bir dosyayı verirsek:

Programın çıktısı aşağıdaki şekilde olur:

533 views

Bu yazının amacı, Java dilindeki vektör sınıfının kullanılmasını ve yapısını anlatmaktır.

Java dilindeki vektörlerin yapısından bahsederek başlayalım. Klasik veri yapısı olarak dizilerin (array) ve bağlı listelerin (linked list) özelliklerini birleştirmiştir.

Bir vektör boyutu belli olmadan tanımlanıp içerisine veri konuldukça hafızada kapladığı yeri arttırmaktadır. Bu anlamda bağlı listelere benzer özellik göstermektedir. Yani bir vektörün boyutunun önceden tanımlanması gerekmez. Aslında vektörün boyu yoktur ve herhangi bir anda vektör için bir limit belirtilmez.

Boyutunu belirsiz tutabilmemizin yanında, bir vektörün herhangi bir elemanına doğrudan erişmek (random acces) de mümkündür. Bu sayede vektör yapısı diziler ve bağlı listelerden daha avantajlı bir hal almış olur.

Vektörler hakkında bilmemiz gereken son özellik ise, vektörlerin tipsiz olduğudur. Yani vektörler içlerinde istenilen tipte veri tutabilir. Bunu, JAVA dilinde bulunan nesne mirası sayesinde yapmaktadırlar. JAVA dilinde, bütün nesneler, Object sınıfından türemiştir. Yani aslında bütün nesneler ile Object sınıfı arasında bir miras (inheritance) ilişkisi bulunmaktadır.

Dolayısıyla JAVA dilindeki bütün nesneler, Object sınıfına yukarı akış yapılarak (upcasting) bu tipte tutulabilir. Aşağıdaki örneklerde bu durumu gösteren kodlar sunulacaktır.

Gelelim vektörlerin, JAVA dilindeki kullanılışlarına

Basit bir uygulama ile bu sınıfı tanımaya başlayalım.

Öncelikle java dilindeki vektör sınıfı, java.util paketi altında bulunabilir. Dolayısıyla vektörler ile çalışırken kodun başına

import java.util.Vector;

yazmak gerekir. Yukarıdaki kodun 14. satırında da bu import işlemi ile koda başlanmıştır.

Kodun ana çalışan sınıfı (class) vektorDeneme isimli sınıftır ve bu sınıfın içerisinde bir adet main fonksiyonu bulunur. Bu fonksiyonun içinde victor isimli bir Vector tanımlanmıştır.

Ayrıca vektörün içerisinde tutulacak veri tipini belirlemek için bir oluşum sınıfı (composition class) tanımı yapılmış ve insan tipinin, boy ve yaş bilgilerinden oluştuğu kodlanmıştır. (kodun 14-23. satırları arası). Bu sınıf içerisinde bir inşa fonksiyonu (yapıcı fonksiyon, constructor) tanımlanmış ve iki tam sayı (int) alarak bir insanı tanımlamaya imkan sağlamıştır.

Kodun 28. satırında, insan tipinde bir ali nesnesi (object) üretilmiş ve bu nesne, 29. satırda, daha önceden tanımladığımız victor ismindeki vektöre yerleştirilmiştir.

Kodun 30. satırında, victor isimli vektörün boyutunun nasıl alındığı gösterilmiştir. Buna göre bir vektör nesnesinin .size() şeklinde metodu çağrılarak, boyutu alınabilir.

Ayrıca vektörün herhangi bir sıradaki elemanına erişmek için .elementAt() fonksiyonunu çağırmak ve bu fonksiyona parametre olarak kaçıncı elemana erişilmek istendiğini vermek yeterlidir.

Ne yazık ki 31. satırdaki çağırma işlemi sonucunda JAVA anlamlı bir şey basamaz. Bunun sebebi, vektörün 0. elemanı olarak konulan nesnenin tipinin belirsiz olması ve şu anda nesne sınıfına (object) çevrilmiş olmasıdır. Vektörün 0. sırasında bulunan bu elemanın üyelerine (members) erişmek için öncelikle insan tipine geri çevrilmesi gerekir. Bunun için tip inkılabı yapıp nesnenin başına parantezler içerisinde (insan) yazılmıştır. Ancak bu çevirim yapıldıktan sonra boy ve yas üyelerine erişilebilmiş ve ekrana basılmıştır.

Yukarıdaki kodun çıktısı aşağıda verilmiştir:

• vektör boyutu: 1
• vektörün 0. elemanı : javaapplication21.insan@190d11
• elemanın insan olarak boyu : 100 yasi : 10

Görüldüğü üzere, çıktının ikinci satırında, JAVA nesneyi ekrana basmıştır. (aslında ekrana basılan nesnenin dizgiye (string) çevrilmiş ve serilenmiş halidir, daha fazla bilgi için nesne serileme (serialization) başlıklı yazıya bakabilirsiniz).

Vektörlerin, JAVA dilinde bir tip kısıtlaması ile kullanılması da mümkündür.

Örneğin yukarıdaki kodda bulunan victor isimli vektöre, yeni elemanlar eklenirken herhangi bir kısıt bulunmaz. İkinci elemanı olarak öğrenci, üçüncü elemanı olarak ders tipinde nesneler eklenebilir. Bu nesnelerin hepsi Object tipine çevrilerek yerleştirilir. Ancak biz kısıtlamak istersek bir şablon tanımı (template) yapmamız mümkündür.

Vector<insan>kisitli = new Vector<insan>();

Şeklindeki tanım, sadece insan tipinden nesneler alabilir. Farklı tiplerdeki nesnelerin bu vektöre konulması mümkün değildir. Aynı zamanda tip dönüşümü yapmak da gerekmez. Yani bir önceki kodda bulunan ve vektörün herhangi bir elemanının boyu veya yaşını bastırmak için başına eklediğimiz (insan) ibaresinin bu kodda bulunması artık gerekmez. Çünkü JAVA bu sınıfların tiplerini bilmektedir ve bu tiplere göre erişime izin verir.

458 views

2-3-4 ağacı, B-ağaçlarının (B-Trees) özel bir halidir. Bu ağacın özelliği, düğüm boyutunun (node size) 3 ile sınırlı olmasıdır. Ağaç ayrıca sürekli olarak dengeli bir ağaç garantisi verir (balanced tree). 2-3-4 ağaçları, kırmızı siyah ağaçlarının (red-black trees) , eş şekillisi (isomorphic) olarak da düşünülebilir.

2-3-4 ağacının ismi, ağaçtaki düğümlerin değişik durumlarda değişik numaralar almasından kaynaklanmaktadır. Yani bir düğüm 2,3 veya 4 durumunda olabilir. Bu durumlara göre farklı uygulamalar söz konusudur.

2 düğümü: 2 adet çocuk düğümü gösteren gösterici (pointer) ve bir veriden oluşur

3 düğümü: 3 adet çocuk düğümü gösteren gösterici (pointer) ve iki veriden oluşur

4 düğümü: 4 adet çocuk düğümü gösteren gösterici (pointer) ve üç veriden oluşur

Ekleme işlemini bir örnek üzerinden anlamaya çalışalım

50, 27, 97, 52, 19, 11, 111

Bu sırayla verilen değerleri sırasıyla ağaca ekleyelim:

İlk sayı olan 50′nin eklenmesi sonucunda ağaçta tek bir düğüm ve bu düğümde tek bir veri bulunuyor. Bu tip düğüme 2 düğümü ismi verilmektedir ve iki çocuğu da boştur (null).

İkinci eklenen değer 27′dir. Ağacımızda tek düğüm bulunduğundan ve bu düğüm 2 tipinde olduğundan, düğümde yeni değeri alacak yer bulunmaktadır. Bu yere yeni gelen değer yerleştirilir. Elbette düğümlerin içerisinde sıra bulunması gerektiği için, 27 değeri, 50 değerinin soluna yerleştirilmiştir. Bu kural bundan sonraki ekleme işlemlerinde de geçerli olacaktır. Yani düğüm içerisindeki değerler kendi aralarında sıralı olacak ve herhangi bir değerin solundaki çocuklarının değeri, kendi değerinden küçük ve sağındaki değeri kendi değerinden büyük olacaktır.

Ardından gelen ekleme değeri, 97′dir. Bu değer düğüme eklenince, aşağıdaki gibi bir yapı elde edilir:

Yukarıdaki bu yeni yapı, bizim 2-3-4 ağacımızdaki 4 tipindeki yapıdır ve kabul edilebilir bir durumdur. Ancak bir sayı daha eklenince yapı bozulacaktır. Nitekim sıradaki sayımız olan 52′nin eklendiğini düşünelim:

Şimdiye kadar öğrendiklerimize göre, yukarıdaki gibi bir yapı olması beklenir. Ancak yukarıdaki yapı 2-3-4 ağacı tarafından kabul edilemez (2,3 veya 4 tipinde bir düğüm değildir). Dolayısıyla bu yapının kabul edilir bir şekle indirgenmesi gerekir.

Yukarıdaki yeni şekilde, ağaç 50 ve 27 değerlerini taşıyan iki adet 2 tipinde düğüm ve bir adet 52 ve 97 değerlerini taşıyan 3 tipinde düğüme indirgenmiştir. Bu düğümlerin tamamı 2-3-4 ağacı tarafından kabul edilir düğümlerdir.

Ekleme işlemine 19 sayısı ile devam edelim.

Yukarıdaki şekilde görüldüğü üzere, 19 sayısı, 50′den küçük olduğu için kökteki bu değerin solundaki düğüme yerleştirilmiştir.

11 sayısı eklendikten sonra, bu sayı da daha önceden olduğu gibi, 50′nin solundaki düğüme sıralı olarak eklenir.

Benzer şekilde 111 sayısının eklenmesi de kök değerin sağına yapılır:

Son olarak ağacın 3 düğümü olarak taşıyamayacağı bir örneği göstermek için, örneğin 120 sayısını ağaca eklemeye çalışalım:

Normalde 120 sayısının ekleneceği yer, yukarıdaki şekilde gösterildiği gibi ağacın sağ koludur. Ancak bu durum 2-3-4 ağacı tarafından kabul edilemez çünkü herhangi bir düğüm yapısına uygun değildir.

Çözüm olarak daha önceden 52 sayısının eklendiği örnekte olduğu gibi düğümleri indirgiyoruz.

Bu işlemden sonra kök düğümünü güncelleyerek sonuçta çıkacak olan ağacı elde ediyoruz

Ağacımız son halinde 2-3-4 ağacı kurallarına uygun düğümlerden oluşmaktadır.

656 views

Bilgisayar bilimlerinde sıkça kullanılan sonlu durum makinelerinin (finite state machine, FSM veya Finite State Automaton , FSA) gösteriminde kullanılan iki farklı yöntemdir. Genelde literatürde bir FSM’in gösteriminde en çok moore makinesi kullanılır. Bu iki yöntem (mealy ve moore makinaları) sonuçta bir gösterim farkı olduğu için bütün mealy gösterimlerinin moore ve bütün moore gösterimlerinin mealy gösterimine çevrilmesi mümkündür.

Klasik bir FSM’de bir giriş bir de çıkış bulunur (input / output). Bu değerlerin nereye yazılacağı aslında iki makine arasındaki farkı belirler.

Moore makinelerinde çıkış değerleri düğümlere (node) yazılırken, giriş değerleri kenarlar (edges) üzerinde gösterilir.

Mealy makinelerinde ise giriş ve çıkış değerleri kenarlar (edges) üzerinde aralarına bir taksim işareti (slash) konularak gösterilir. Örneğin 1/0 gösterimi, girişin 1 ve çıktının 0 olduğunu ifade eder.

Basit bir örnek olarak özel veya (exclusive or, Ä) işlemini ele alalım ve her iki makine gösterimi ile de çizmeye çalışalım.

Klasik bir XOR kapısı, yukarıdaki doğruluk çizelgesinde (truth table) gösterildiği üzere iki giriş ve bir çıkıştan oluşur. Bizim makinemiz de ilk girdiden sonra ikinci girdiyi aldığında beklenen çıktıyı vermeli. Ayrıca makine sürekli olarak çalışmaya devam edecek. Örneğin 101011 şeklinde bir veri akışı sağlanması durumunda, sonuç olarak 1Ä0Ä1Ä0Ä1Ä1 değerini hesaplamasını isteriz.

Yukarıdaki gösterim bir mealy makinesidir. Makinede görüldüğü üzere 3 farklı durum arasındaki geçişler üzerine iki adet değer yazılmıştır. Bu değerlerden ilki giriş ikincisi ise çıkış değeridir.

Makineyi beraber okumaya çalışalım.

Makinenin boşluktan bir ok ile başlayan durumu, yani örneğimizdeki S0 durumu, başlangıç durumudur. Bu durumdan başlanarak gelen değerlere göre ilgili duruma geçilir.

Örneğimizi hatırlayalım. Giriş olarak 101011 dizgisini (string) almayı planlamıştık. Bu durumda ilk bitimiz 1 olarak geliyor ve S0 durumunda 1 girişi ile S2 durumuna geçiyoruz. Burada geçiş sırasında kullanılan kenarın üzerindeki değeri okuyalım: 1/0 bunun anlamı 1 geldiğinde geçilecek kenar olması ve çıktının 0 olmasıdır. Yani şu anda çıktımız 0

Ardından gelen değer 0 (yani şimdiye kadar 01 değerleri geldi). En son makinemizdeki durum, S2 durumuydu, şimdi yeni gelen değeri bu durumdaki kollardan takip ediyor ve S1′e giden 0/1 kenarını izliyoruz. Bu kolu izleme sebebimiz, S2 durumundan gidilen tek 0 girdisi kolu olmasıdır. Bu kol üzerindeki ikinci değer olan 1 ise, çıktının 1 olduğudur. Yani buraya kadar olan girdiyi alacak olsaydık 01 için 1 çıktısı alacaktık.

İşlemlere devam edelim ve durumları yazmaya çalışalım:

Yukarıdaki tablomuzun son halinde, çıkış değeri olarak 0 okunmuştur. Yani örneğimizin neticesi 0 olacaktır.

Aynı örneği moore makinesi olarak tasarlayacak olsaydık:

Moore makinesinde, mealy makinesine benzer şekilde boşluktan gelen bir ok, başlangıç durumunu belirtir.

Makinenin, durumlarında, mealy makinesinde olmayan değerler eklenmiştir. Bu değerler, ilgili durumdaki çıktıyı gösterir. Örneğin makinemiz S1 durumundayken çıktı 0 olarak okunabilir.

Şimdi moore makinesinde, aynı örneği çalıştırıp sonucu karşılaştıralım.

Giriş olarak 101011 dizgisini (string) almayı planlamıştık. Bu durumda ilk bitimiz 1 olarak geliyor ve S0 durumunda 1 girişi ile S2 durumuna geçiyoruz. Bu geçiş sonucunda geldiğimiz S2 durumunda okunan çıktı değeri 0 yani sonuç şimdilik 0.

Ardından gelen 0 değeri ile S3 durumuna geçiyoruz ve çıktımız 1 oluyor. Çünkü S3 durumu 1 çıktısı veren durumdur. Bu şekilde durumları ve durumlar arasındaki geçişleri izlersek, aşağıdaki tabloyu çıkarabiliriz:

Görüldüğü üzere, makinemiz, örnek girdi için S2 durumunda sonlanıyor ve bu durumda çıktımız 0 olarak okunuyor.

812 views

Bilgisayar bilimlerinde kullanılan bir veri yapısıdır (data structures). Özel bir ağaç yapısıdır ve amaç ağacı sürekli olarak dengeli (balanced) tutmaktır.

Ağaçtaki düğümlere (nodes) isim olarak 2 veya 3 ismi verilebilir. Her düğüm aldığı isme göre farklı işleme tabi tutulur. Düğümlerin isimlendirilmesi aşağıdaki şekilde yapılır:

2 düğümleri (2 nodes) : 2 adet çocuğu ve bir veri elemanı bulunan düğüm yapısıdır

3 düğümleri (3 nodes) : 3 adet çocuğu ve iki veri elemanı bulunan düğüm yapısıdır.

2-3 Ağacına Ekleme işlemli

Ağaca eklemeyi bir örnek üzerinden adım adım görelim. Ağacımıza ekleyeceğimiz sayılar aşağıdaki şekilde veriliyor olsun:

50, 27, 97, 52, 19, 11, 111

Bu sırayla verilen değerleri sırasıyla ağaca ekleyelim:

İlk sayı olan 50′nin eklenmesi sonucunda ağaçta tek bir düğüm ve bu düğümde tek bir veri bulunuyor. Bu tip düğüme 2 düğümü ismi verilmektedir ve iki çocuğu da boştur (null).

İkinci eklenen değer 27′dir. Ağacımızda tek düğüm bulunduğundan ve bu düğüm 2 tipinde olduğundan, düğümde yeni değeri alacak yer bulunmaktadır. Bu yere yeni gelen değer yerleştirilir. Elbette düğümlerin içerisinde sıra bulunması gerektiği için, 27 değeri, 50 değerinin soluna yerleştirilmiştir. Bu kural bundan sonraki ekleme işlemlerinde de geçerli olacaktır. Yani düğüm içerisindeki değerler kendi aralarında sıralı olacak ve herhangi bir değerin solundaki çocuklarının değeri, kendi değerinden küçük ve sağındaki değeri kendi değerinden büyük olacaktır.

Ardından gelen ekleme değeri, 97′dir. Bu değer düğüme eklenince, aslında aşağıdaki gibi bir yapı elde edilir:

Ancak ne yazık ki 2-3 ağaçlarında, 3 adet değeri tek bir düğümde bulundurma şansımız yoktur. Bu yüzden yukarıdaki bu hayali yapı bölünerek aşağıdaki şekle geçilir ve 3 adet 2 tipinde düğümümüz olur:

Yeni gelen değerimiz 52′dir:

Yukarıdaki yeni şekilde, gelen 52 değeri, kök düğüm olan 50′den başlanarak ağaçta ufak bir dolaşmaya sebep olur. Öncelikle 50′den küçük olduğu için bu düğümün sağına sonra da 97′den küçük olduğu için bu düğümün soluna yerleştirilir.

52 değerinin, 50 değerinin sağına yerleştirilmemesinin sebebi, bu durumda ağaçta iki veri ve iki çocuk bulunan aşağıdaki hayali ağacın oluşmasıdır:

Yukarıdaki bu hayali ağaç ne yazık ki 2-3 ağaçlarında yer almaz. Tekrar hatırlatacak olursak 2-3 ağaçlarında 2 düğümlerinin 2 çocuk ve bir verisi, 3 düğümlerinin ise 3 çocuk ve 2 verisi bulunur. Yukarıdaki kök düğüm ise 2 veri ve 2 çocuk bulundurmaktadır. Bu durum kabul edilemez.

Yeni eklenen değerimiz 19:

Yukarıdaki bu yeni ağaç yapısı, bir önceki adımda açıklandığı gibi, 50′nin yanına yeni bir veri eklenememesinden dolayı, 50′nin solundaki düğüme eklenmesi sonucunda elde edilmiştir.

Sıradaki eklenecek olan veri 11′dir. Eklenmiş halini görmeden önce, hayali olarak ağaçta olması beklenen adımları açıklayalım. Öncelikle verinin eklenmek isteneceği yer, 50 değerindeki kök düğümünün soludur.

Yukarıdaki hayali ağaç, ne yazık ki 2-3 ağaçları tarafından kabul edilemez. Dolayısıyla üç veri içeren bu düğümü tek başına ele aldığımızda (ki aynı durum, örneğimizde 97 eklenirken de yaşanmış ve 3 adet veri yan yana elde edilmesin diye 3 adet 2 tipinde düğüme dönüştürülmüştü) bölünme işlemi gerçekleştirilir:

Yukarıdaki bu alt ağacı, bir önceki ağacımız ile birleştirirsek:

Elde ettiğimiz yeni ağaç, yukarıdaki şekilde iki ağacın birleştirilmiş hali olur.

Son olarak ekleyeceğimiz değer 111 olsun. Bu değer eklendiğinde ağaçta bir zincirleme reaksiyon oluşur ve birden fazla düğümün yukarıya doğru bölünmesi gerekir. Öncelikle 111 değeri 50′den büyük olduğu için, ağaçta 50′nin sağındaki gösterici (pointer) tarafından gösterilen düğüme yönlendirilir ve sanki aşağıdaki hayali ağacın oluşmasına sebep olur:

Elbette yukarıdaki bu 3 veriyi yan yana tutan düğümü kabul edemeyeceğimiz için bu düğümü bölüyoruz:

Bu sefer kök düğümdeki 3 veriyi kabul edemeyeceğimizden dolayı, kök düğümü de bölüyoruz:

Sonuçta, yukarıdaki ağaç 2-3 ağacı olarak bütün değerlerin eklendiği ağaçtır. Buradaki son bölünmeden sonra toplam 7 adet 2 tipinde düğüm elde edilmiştir. Ayrıca yukarıdaki ekleme işlemleri boyunca her adıma bakıldığında ağacın dengeli bir ağaç olduğu (bütün yaprak düğümlerinin (leaf nodes) aynı seviyede olduğu ) görülebilir.

Aslında yukarıdaki isimlendirmeler, B-Ağacının (B-Tree) özel bir şekli olarak düşünülebilir. Yani, düğüm boyutu 2 olan bir b-ağacında, her düğümde ya iki ya da tek eleman bulunacak ve bulunan eleman sayısının bir fazlası kadar çocuk bulunacaktır.

2-3 Ağaçları, AA ağaçlarının (AA-trees), eş şekillisi (isometry) olarak düşünülebilir.

499 views

Siteye gelen bir soru üzerine bu yazıyı ekliyorum. Öncelik sırası (priority queue), kullanarak gelen hastaları verilen önceliğe göre dairesel bir bağlı listeye (linked list) yerleştiren ve ardından sırayla gelen hastaları listeden alan bir kodu C++ dilinde yazalım.

İlk olarak bir hastanın tanımını yapan sınıfı aşağıdaki şekilde kodluyoruz:

Bu tanıma göre bir hasta, ad, soyad ve sıradaki önceliğini bilmektedir. Bu sınıftan üretilen her hasta için bu bilgilerin girilebileceğini kabul ediyoruz.

Ayrıca yukarıdaki hasta sınıfında, yine sınıf ile aynı isme sahip bir inşa fonksiyonu (constructor) bulunmaktadır. Buradaki amaç, nesne (object) oluşturulurken bu aşamada ilk değerlerini atamaktır.

Hasta sınıfını tanımladıktan sonra, bağlı listenin her bir düğümünü (node) tutacak olan sınıfa geçebiliriz. Yukarıdaki sınıf tanımında siraEleman ismi verilen bu yapıda, bir veri bir de sonraki üyeleri bulunmaktadır. Basitçe, veri göstericisi her düğümde duran anlık veriyi ve sonraki göstericisi ise bağlı listemizin sıradaki elemanını gösterecektir.

Sonuçta üretmeyi planladığımız bağlı listeyi aşağıdaki şekilde çizebiliriz:

Yukarıdaki temsili resimde olduğu gibi, her düğüm (yuvarlak olarak tasvir edilmiştir), bir adet veriyi (kutu olarak tasvir edilmiştir) ve yine kendi cinsinden başka bir düğümü göstermektedir.

Sonuçta bağlı liste yapısı dairesel olmaktadır.

Yukarıda kodu verilen, siraEleman sınıfı işte bu resimdeki yuvarlak olarak tasvir edilen düğümleri tutmakta, hasta sınıfı ise kutularla gösterilen değerleri tutmaktadır.

Yukarıdaki temel sınıfları tanımladıktan sonra, ana sınıfımız olan ve bağlı listenin kodlandığı sira sınıfını kodlamaya geçebiliriz.

Sınıfımızda 3 adet temel fonksiyon bulunacaktır. Bunlar ekleme işlemi yapan ekle fonksiyonu, sıradaki hastayı alan siradaki fonksiyonu ve bağlı listenin durumunu bastıran bastir fonksiyonudur.

Sırasıyla bu fonksiyonların kodlamasını inceleyelim:

Yukarıdaki kodda, sıra bilgisini tutarken, sıranın ilk elemanını gösteren bir gösterici tanımlanmıştır. Bu gösterici “ilk” ismiyle isimlendirilmiş olup 27. satırda tanımlandıktan sonra, 28. satırda bulunan inşa fonksiyonu (constructor) içerisinde ilk değeri atanmıştır. Buna göre ilk göstericisi, ilk başta NULL değer taşımaktadır. Bunu elle özel olarak yazıyor olmamız, kodun geliştirildiği Dev-CPP ortamından kaynaklanmaktadır. Normalde bazı derleyiciler, bir göstericinin içerisine değer konulmadığı zaman NULL değerini atar, ancak Dev-CPP ortamında bu işlemi elle yapmak gerekmektedir.

Sonuçta inşa fonksiyonumuz çalıştıktan sonra elimizde bir ilk isimli gösterici (pointer) ve bu göstericinin gösterdiği bir NULL değeri olacaktır. Bu durum, bizim listemizin boş olduğu durumdur.

Gelelim en kritik fonksiyonumuz olan ve 31. Satırdan itibaren başlayan ekle fonksiyonuna. Bu fonksiyon öncelikle eklenecek olan hastayı gösteren bir gösterici almaktadır. Ardından bu hastayı önceliğine göre, dairesel listemize eklemektedir.

Fonksiyonda görüldüğü üzere 3 ihtimal değerlendirilmiştir. İlk if satırımızda (32. satır) listenin boş olup olmadığı kontrol edilmiştir.

Şayet liste henüz boşken ekleme işlemi yapılmak isteniyorsa, bu durumda tek bir düğüm oluşturup bu düğümün sonraki elemanı olarak gene kendisini işaretliyoruz. (listenin dairesel liste olması gerektiğini hatırlayınız).

Ayrıca listemizin ilk elemanını gösteren ilk göstericisi de bu yeni oluşturulan düğümü göstermektedir.

İkinci kontrolümüz (kodun 36. Satırında) bağlı listeye eklenen ilk elemandan daha önde olması gereken bir eleman olması durumunu incelemektedir.

Bu kontrol oldukça önemlidir ve dikkatsiz bir kodlamada gözden kaçabilir.

Listenin ilk elemanını gösteren ilk isimli gösterici sabit düşünülürse, bu durumda bu göstericinin gösterdiği düğümün değerine göre daha öncelikli birisi gelmesi durumunda hata oluşur. Çözüm olarak kodun 36. Satırında bulunan if kontrolü eklenmiştir.

Kontrolden geçilmesi durumunda yapmamız gereken en önemli eylem, ilk elemanımızı gösteren elemanı bulmaktır. Bunun sebebi dairesel bir listeye ekleme yapılırken, listenin ilk elemanını, listenin son elemanını göstermesi özelliğini bozmamaktır.

Örneğin aşağıdaki şekilde bir bağlı listemiz bulunsun:

Yeni gelen (ve resimde yeşil renkle gösterilen) elemanı, listeye ekleyeceğimizi düşünelim. Ayrıca listenin başına eklemek istediğimizi de düşünelim.

Bu durumda ilk elemanı gösteren ve listenin sonunda olan elemanın sonrasına bu yeni gelen yeşil eleman eklenecektir.

Sonuç olarak ilave bir gösterici ile listede hareket edip ilk göstericisini kaybetmeden listenin sonuna gitmemiz gerekiyor. Kodda bu göstericiye iter adı verilmiştir (iter kelimesi iterator kelimesinin kısaltması olarak liste içerisinde dolaşan bir göstericiye atfen verilmiştir).

Yukarıdaki şekilde, iter göstericisi son elemanı gösterdikten sonra ekleme işlemi yapılabilir. İter göstericisinin sona gitmesini sağlayan, kodun 38. satırındaki while döngüsüdür. Ardından iter->sonraki = yeni denilerek önce son elemandan yeni elemana bir gösterici atanmaktadır:

Ardından yeni->sonraki = ilk denilerek bu yeni eklenen elemanın sonrasına ilk eleman konulmaktadır.

Son olarak yeni eklenen bu elemanı listenin başı yapmak için ilk= yeni denilmektedir:

Artık listemiz, yukarıdaki şekilde de görüldüğü üzere, yeşil elemandan başlayıp, dairesel bir şekilde hafızada tutulmaktadır.

Gelelim ekleme işleminin son koşulu olan ve 45. Satırdan başlayan else bloğuna.

Bu durum, listenin boş olması ve listenin en başına eklenmesi durumları dışında kalan durumları tutmaktadır.

Listenin sonuna veya aradaki herhangi iki düğüm arasına eklemek için bu blok çalışır.

İşlem oldukça basit bir şekilde, eklenecek olan düğüme kadar önceliklere dikkat ederek ilerleme esasına dayanır. Kodun 48. satırındaki while döngüsü, liste sonu veya öncelik sırasında bizden sonrakileri atlayarak ilerler. Bizden önceliksiz birisi gelince bizi eklemek için durur. Bu kontrol sırasında, tek eleman bulunması ihtimali veya listenin sonuna eklenmesi ihtimaline karşı ilave bir if satırı daha eklenmiştir.

İşlem basitçe yeni bir düğüm oluşturup, ekleme işlemi yapacağımız düğümden sonrasının sonrasını, geçici bir göstericide (pointer) tutmaktadır.

Ekleme işlemi yapılıp eklenecek düğümden sonrasına, yeni düğüm bağlandıktan sonra, işte bu geçici düğüm, yeni düğümümüzün sonrasına bağlanmaktadır.

Sıradaki hastanın alınması işlemi için olan kodlamamız aşağıdaki şekildedir:

Yukarıdaki kodda, ekleme koduna benzer şekilde 3 ihtimal değerlendirilmiştir. İlk ihtimalde, liste boşken, sıradaki hasta istendiğinde, NULL değer döndürülmektedir.

İkinci ihtimalde, şayet listedeki son hasta da alınırsa, bu durumda liste boş hale getirilmektedir. Koddaki 63. Satırda bulunan free komutu gerekmemekle birlikte, kullanılmaması durumunda hafızada (RAM) tutulmakta olan hasta bilgileri silinmez. Uzun süreli kullanımlarda hafızada bu tip veri kırıntılarının kalması performans kaybına ve nihayetinde programın bozulmasına sebep olur. Bu yüzden hafızada bulunan bütün nesneleri, işimiz bittikten sonra free komutu ile kaldırmamız gerekir.

Free komutunu kullanabilmek için, geçici bir pointer (temp) tanımlanmalıdır. Bu tanımlamayı yapmadan free yaparsak, hasta bilgileri silinir. Dolayısıyla önce hasta bilgileri geçici bir göstericiye atanır, sonra free yapılıp bu geçici göstericinin değeri fonksiyon sonucu olarak döndürülür (return).

Son else koşulu ise, diğer bütün durumları (listenin boş olmaması ve listedeki son hastanın alınmaması durumunu) kapsar.

Basitçe sıradaki eleman ilk göstericisinin gösterdiği elemandır. Bu eleman alınıp, free yapıldıktan sonra döndürülür.

Bastır fonksiyonumuz, listenin ilk elemanını gösteren ilk göstericisinden başlayarak listedeki bütün elemanları bir döngüyle dolaşarak bastırır. Burada dolaşma işleminin bitmesinin ardından iter isimli, listeyi dolaşan gösterici, listenin son elemanını bastırmadan çıkar. Çözüm olarak 81. satırdaki gibi ilave bir bastırma işlemine ihtiyaç duyulur.

Kodun testi için, yukarıdaki gibi bir main fonksiyonu hazırladım. Basitçe 5 hastayı, karışık şekillerde ekliyor ve arından 3 kişiyi sıradan istiyor. Ekran çıktısı aşağıdaki şekilde başarılı çalışmaktadır.

Yukarıdaki çıktıda görülen bir takım kontrol satırları (debug) koddaki çalışmayı göstermektedir. Kodun son 3 satırı, istediğimiz sıradaki hastaları vermektdir. En yüksek öneme sahip olan sadi-seker-6 ilk gelmekte sonra 5 ve 4 önemlerine sahip kişiler çıkmaktadır.

Bu son 3 satırdan önceki 5 satır ise, listenin son durumunu göstermektedir. Görüldüğü üzere listedeki 5 kişi önem sırasına göre yerleştirilmiştir.

Kodun tamamına erişmek için tıklayınız.

521 views