Algoritma Geliştirme ve Veri Yapıları 6 Arama ve Sıralama Algoritmaları
Arama ve sıralama algoritmaları bilişim uygulamalarında önemli bir yer tutar. Çünkü bilgiye ait verinin saklanması ve gerektiğinde bir parçası ile kalan bütününe erişilmesi veya bilginin belirli bir düzene göre sıralanması çoğu zaman ihtiyaç duyulan bir işlemdir. Arama ve sıralama algoritmaları, bu işlemlerin yanı sıra benzer mantıkta olan problemlerin çözümü konusunda da kolaylık sağlayabilmektedir.
Temel Kavramlar Sıralama, sayısal ortamdaki bilgilerin belirli bir anahtar sözcüğe göre belirli bir anlamda sıralı hale getirilmesidir. Arama, bir veri kümesi içerisindeki bir bilginin varlığının belirlenmesi, yerinin bulunması veya verinin bir parçasından bütününe erişilmesi işlemdir. Arama işlemi belirli bir veya birkaç anahtar sözcüğe dayanılarak gerçekleştirilir. Kullanılan bu anahtar sözcükler iki farklı şekilde olabilir: birincil ve ikincil.
Temel Kavramlar Birincil Anahtar Sözcük Birincil anahtar sözcüğe göre arama yapılırsa, yalnızca bir tane sonuç bulunmalıdır. Dolayısıyla bu anahtar sözcüğe göre arama yapılıyorsa aranan bulununca geride kalan kayıtlara bakılmaksızın arama işlemi sonlandırılır. İkincil Anahtar Sözcük İkincil anahtar sözcüğe göre arama yapılırsa aranan sözcüğe en uygun birden fazla sonuç elde edilebilir; dolayısıyla ikincil anahtar sözcüğe göre arama yapan algoritmalar var olan kayıtların hepsini sınamış olmalıdır. Gerektiğinde sonuç liste üzerinde tutulmalıdır.
Temel Kavramlar Arama işlemi bellek üzerinde tutulan veriler üzerinde yapılıyorsa dahili, disk gibi saklama birimleri üzerinde yapılıyorsa harici arama olarak adlandırılır. Dahili Algoritma Arama veya sıralama işlemleri RAM gibi bellek üzerinde tutulan veriler üzerinden yapılır. Veriye erişim hızlı olduğu için verilerin yer değiştirilmesi, araya ekleme, aradan çıkarma gibi işlemler daha hızlı gerçekleşir. Yani verilerin bellek üzerindeki konumunun bir önemi yoktur. Harici Algoritma Arama veya sıralama işlemleri disk, yedekleme birimi gibi belleğe göre daha yavaş olan saklama birimleri üzerinde yapılır. Diske erişim belleğe göre daha yavaş olacağından verilerin yer değiştirmesi, bir veriden diğerine atlanması vs. gibi işlemlerin oldukça fazla zaman harcar. Bu nedenle de bu birimler üzerinde yapılacak işlem sırasında verilerin fazla hareket ettirilmemesi gerekmektedir.
1) Arama Algoritmaları Arama algoritmaları bir veri kümesi içerisinde herhangi bir parçasının varlığını arama veya bir parçası ile kalan diğer bütününü arayıp bulmak için kullanılır. Arama işleminin yapılış şekli, bilgiye ait verilerin düzenlenmesi ve bellekte tutulmasına göre farklılık gösterebilir. En yalın arama şekli, bilgiye ait verilere baştan sona kadar tek tek bakılarak yapılmasıdır(ardışıl arama). Bu yöntemde arama algoritması kolay yazılır fakat arama hızı düşüktür.
1) Arama Algoritmaları Arama algoritmaları 3 temel sınıfta toplanabilir; o o o Ardışıl (Doğrusal) Arama İkili Arama Çırpı (Hash) Algortiması Uygulamada çoğunlukla ikili arama algoritmaları tercih edilirken, en hızlı arama algoritması olan çırpı algoritmasının kullanılabilmesi için çatışmaların olmadığı ideal bir çırpı fonksiyonun bulunması gerekmektedir.
1.1-Ardışıl Arama Algoritması Tasarımı en yalın arama algoritmasıdır. Yöntem olarak ilk kayıttan son kayda kadar tüm veriler tek tek aranılan değerle karşılaştırılır. Eğer arama işlemi birincil anahtar sözcük üzerinden yapılıyorsa aranılan sonuç bulunduğunda işlem sonlandırılır. Eğer arama işlemi ikincil anahtar sözcüğe dayanılarak yapılıyorsa son kayda kadar işlem devam eder.
1.1-Ardışıl Arama Algoritması Ardışıl aramanın en kötü durumdaki zaman karmaşıklığı O(N) dir. Yani N kayıttan oluşan bir veri yapısında en kötü durum N çevrim yapılmasıdır(son kayıt için).
int ardisilarama(int A[], int N, int aranan){ int k; for(k=0;k<n;k++) /*N çevrimlik döngü*/ if(a[k]== aranan) return k; /* Aranan bulundu indisi gönder*/ return -1; /*Bulunamadı -1 gönder*/ main(){ int indis,ara,b[]={13,12,15,11,26,5,47,10,27,34; puts( Aranan Sayi: ); scanf( %d,&ara); indis= ardisilarama(b,10,ara); /*10 elemanlı dizide arama yapılıyor*/ if(indis ==1) puts( Aranan sayi bulunamadi! ); else printf( Aranan sayi %d indisli eleman\n, indis);
1.2-İkili Arama Algoritması İkili arama, halihazırda sıralı olan veriler üzerinde çalışan bir algoritmadır, yani verilerin önceden, belirli anahtar sözcüğe göre sıralı olmalıdır. Eğer veriler bir dizi üzerinde sıralı ise veya veriler ikili arama ağacı üzerinde tutuluyorsa ikili arama yapılabilir. İkili aramanın zaman karmaşıklığı O(log 2 N). 1 milyon kayıt içerisinde arama için gerekli çevrim sayısı log 2 1000000=~20. Bu yüzden kayıt sayısı fazla olan veri kümelerinde arama için idealdir(ardışıl ile en kötü durumda 1 milyon çevrim)
int ikiliarama(int D[], int N, int aranan){ int ortadaki, sol=0, sag=n-1; while(sol<=sag) { ortadaki=(sol+sag)/2; /* ortadaki elemanın indisi hesaplanıyor */ if(aranan == D[ortadaki]) return ortadaki; /* bulundu, indis gönderiliyor */ else if(aranan>d[ortadaki]) sol=ortadaki+1; else sag=ortadaki-1; return -1; /* bulunamaz ise -1 değeri gönderiliyor */ main(){ int indis,ara,b[]={1,2,3,4,5,6,7,8,9,10; puts( Aranan Sayi: ); scanf( %d,&ara); indis= ikiliarama(b,10,ara); /*10 elemanlı dizide arama yapılıyor*/ if(indis ==1) puts( Aranan sayi bulunamadi! ); else printf( Aranan sayi %d indisli eleman\n, indis);
İkili arama ağacı üzerinde arama void ikiliaramaagac(agacdugum *agac, veritürü aranan) { if(agac==null) return; /* Ağaç boş ise dön */ if(aranan==agac->anahtar) /* aranan kök düğümde ise bulundu */ yazekrana(agac); if(aranan < agac->anahtar) /* aranan hangi alt ağaçta? */ ikiliaramaagac(agac->sol); /* sol altağaca dallan */ else ikiliaramaagac(agac->sag); /* sağ altağaca dallan */
1.3-Çırpı Fonksiyonu Çırpı fonksiyonu arama işlemini bir çırpıda yapmak ve aranana doğrudan ulaşmak için kullanılan bir yöntemdir. Fonksiyona arama işleminde kullanılacak anahtar sözcük değeri girilir ve karşılığında bir tamsayı alınır. Bu tamsayı, indis gibi kullanılarak dizi düzeninde tutulan veriye erişilir. Zaman karşılığı idealde O(1) olur. Ancak uygulamada her zaman için ideal bir çırpı fonksiyonu bulmak veya üretmek mümkün olmadığı durumda sapmalar olmaktadır.bütünüyle bir çırpı algoritması; çırpı fonksiyonu, çırpı tablosu ve çatışmaların çözümlenmesi gibi üç ayrı parçadan oluşur. Çırpı fonksiyonu farklı anahtar sözcükler için aynı indis değerini üretiyorsa çatışma olur. Eğer çatışma oluşturmayan bir çırpı fonksiyonu bulunamıyorsa, işin çatışmalarla yürütülmesi gerekmektedir. Bu işleme çatışmaların çözümlenmesi adı verilmektedir.
2) Sıralama Algoritmaları Sıralama, bilgilerin/verilerin belirli bir anahtar sözcüğe göre belirli bir anlamda sıralı duruma getirilmesidir. Sıralama işleminde bir anahtar sözcük kullanılır ve sıralamada ana unsurdur. Anahtar sözcük verinin bir parçası olabileceği gibi tamamı da olabilir. Bir sıralama algoritması için önemli unsurlar, yürütme zamanı ve gerekli bellek alanı ihtiyacıdır. Yürütme zamanı doğrudan algoritma için yazılan koda ve işlemlerin hangi ortamda yapıldığına bağlı iken, gerekli bellek alanını algoritma belirler.
2) Sıralama Algoritmaları Sıralama Algoritması Uygun Veri Modeli Uygunluk Araya Sokma Bağlantılı Liste, Dizi Dahili Seçmeli Dizi, Bağlantılı Liste Dahili Harici Kabarcık Dizi, Bağlantılı Liste Dahili Birleşmeli Bağlantılı Liste, Liste,Dizi Dahili Harici Kümeleme Bağlantılı Liste, Dizi Dahili Hızlı Sıralama Dizi, Ağaç Dahili
2.1-Araya Sokma Algoritması Bu algoritmada, sıralanacak dizinin ilk elemanı yerinde bırakılarak daha sonraki elemanlar tek tek ele alınır ve dizideki sırasına uygun yere konulur. Sıralama süreci boyunca dizi iki parça gibi düşünülür; sıralı olan ön taraf ve henüz sıralanmamış arka taraf gibi. Algoritmada, araya sokulacak elemanın yerini bulma ve geride kalanları birer kaydırma işlemi bulunmaktadır. Bir algoritmada bir eleman eklemenin zaman karmaşıklığı O(n) iken sırasız bir diziyi tamamen sıralamak için zaman karmaşıklığı O(n 2 ) olmaktadır. Algoritma harici sıralama için daha uygundur çünkü elemanların yerlerinin boşaltılması ve eleman kaydırma işlemi gerektirmektedir.
2.1-Araya Sokma Algoritması arayasokma(int D[], int N){ int i, k,ekle; for(i=0; i<n; i++){ ekle=d[i]; for(k=i-1;k>=0 && ekle<=d[k]; k--) D[k+1]=D[k]; /* boşalan düğümün bellek alanı serbest bırakılıyor */ D[k+1]=ekle; /* koy-ekle modu */
2.2-Seçmeli Sıralama Bu algoritmada dizinin herhangi bir ucundan başlanır. Dizinin başından başlandığı ve küçükten büyüğe doğru sıralama yapılacağı varsayılırsa algoritmanın davranışı şöyledir: o o İlk eleman alınır ve kendisi dahil en küçük eleman aranır. En küçük bulunduğu zaman ilk eleman ile yer değiştirilir. o İkinci eleman alınır ve kendisi dahil kalan elemanlar arasında ikinci küçük eleman aranır ve ikinci elemanla yer değiştirilir. Seçmeli sıralama algoritmasının en olumlu yanı, eğer herhangi bir eleman gerçek yerinde ise yer değiştirme işlemi yapılmamasıdır. Bu nedenle yarı sıralı dizilerde toplam yer değiştirme oranı daha az olur.
Sıralanacak Dizi: [7, 3, 5, 8, 2, 9, 4, 15, 6] Başlangıç Durumu: [7, 3, 5, 8, 2, 9, 4, 15, 6] Adım İşlem Öncesi İşlem Sonrası 1 [] [7, 3, 5, 8, 2, 9, 4, 15, 6] [2][ 3, 5, 8, 7, 9, 4, 15, 6] 2 [2][ 3, 5, 8, 7, 9, 4, 15, 6] [2, 3][ 5, 8, 7, 9, 4, 15, 6] 3 [2, 3][ 5, 8, 7, 9, 4, 15, 6] [2, 3, 4][ 8, 7, 9, 5, 15, 6] 4 [2, 3, 4][ 8, 7, 9, 5, 15, 6] [2, 3, 4, 5][ 7, 9, 8, 15, 6] 5 [2, 3, 4, 5][ 7, 9, 8, 15, 6] [2, 3, 4, 5, 6][ 9, 8, 15, 7] 6 [2, 3, 4, 5, 6][ 9, 8, 15, 7] [2, 3, 4, 5, 6, 7][ 8, 15, 9] 7 [2, 3, 4, 5, 6, 7][ 8, 15, 9] [2, 3, 4, 5, 6, 7, 8][ 15, 9] 8 [2, 3, 4, 5, 6, 7, 8][ 15, 9] [2, 3, 4, 5, 6, 7, 8, 9][15] 9 [2, 3, 4, 5, 6, 7, 8, 9][15] [2, 3, 4, 5, 6, 7, 8, 9, 15][]
2.2-Seçmeli Sıralama secmelisirala(int D[], int N) { int i, index, j, enkucuk; for(i=0; i<(n-1); i++) { /* dizinin başından başlanıyor */ enkucuk=d[n-1]; /* son eleman en küçük kabul ediliyor */ index=n-1; for(j=i; j<(n-1); j++) /* daha küçüğü var mı diye aranıyor */ if(d[j]<enkucuk) { enkucuk=d[j]; index=j; D[index]=D[i]; /* daha küçüğü varsa yer değiştiriliyor */ D[i]=enkucuk;
2.3-Kabarcık Sıralaması Bu algoritmada, sıralanacak elemanlar üzerinde bir yönden diğer yöne doğru ilerlenirken komşu iki elemanın sıraya girecek şekilde yer değiştirmesine dayanır. Yer değiştirme işleminde, komşu iki eleman karşılaştırılır; kendi aralarında uygun yer değiştirmeler yapılır. Bu işlem sıralama bitene kadar tekrarlanır. Elemanlar üzerindeki her bir dolaşma bir tane elemanın gerçek yerine oturmasını sağlar. Dolayısıyla işleme, yerine oturmayan elemanlar üzerinde devam edilir. Kabarcık sıralaması iki çevrim kullanılarak gerçeklenir; biri elemanların üzerinde hareket edilmesi, diğeri yerine oturmayan elemanların işlenmesi için. Her çevrimde bir eleman sıralı durumdaki yerine yerleştiği için ikinci çevrim her seferinde bir eksik yapılır. Kabarcık algoritmasının zaman karmaşıklığı O(n2). Eğer n tane elemandan yalnızca c tanesi sıralı değilse zaman karmaşıklığı O(cn) olur.
2.3-Kabarcık Sıralaması /* Kabarcık sıralama fonksiyonu */ kabarcik(int D[], int N) { int gecici, k, hareket; for(hareket=0; hareket<n-1; hareket++) { for(k=0; k<n-1-hareket; k++) if(d[k]>d[k+1]) { /* komşular karşılaştırılıyor */ gecici=d[k]; /* yer değiştirme kodu */ D[k]=D[k+1]; D[k+1]=gecici;
2.4-Birleşmeli Sıralama Bu sıralama böl ve yönet yaklaşımına dayanır ve dolayısıyla rekürsif tasarlanması doğasına uygundur. Sıralanması istenen küme elemanları, önce iki alt kümeye parçalanır ve fonksiyon kendisini sol alt küme ve sağ alt küme için iki kez çağırır. Parçalama işlemine, alt kümelerdeki eleman sayısı bir olana kadar devam edilir. Alt kümelerde bir tane eleman kalmış ise rekürsif çağırmalar geriye doğru çağırana dönmeye başlar ve geri dönülürken alt kümeler elemanları sıralı olacak biçimde birleştirir.
2.4-Birleşmeli Sıralama birlesmeli(int D[], int sol,int sag) { if(sol<sag) { int k=(sol+sag)/2; birlesmeli(d,sol,k); birlesmeli(d,k+1,k); birlestir(d, sol, k, sag); birlestir(int D[], int sol,int k,int sag){ int i,j, M[],z=0; for(i=sol,j=k+1;i<=k && j<=sag;){ if(d[i]<d[j]){m[z]=d[i]; i++; else{m[z]=d[j]; j++; z++; return M;
2.5-Kümeleme(Heap) Sıralama Kümeleme sıralamasının temeli ikili kümeleme(heap) ağacı kurulmasına dayanır. Sıralanacak elemanlar ile önce bir kümeleme ağacı oluşturulur, bu durumda kök en büyük değere sahiptir. n elemanlı bir dizi üzerinde önce kümeleme ağacı kurulur, bu anda kök en büyük değeri tutar. Bu değer dizinin son elemanı ile yer değiştirilir. Bu aşamada en büyük değere sahip olan eleman dizinin sonuna alınmış olur, daha sonra dizinin kalan(n-1) elemanı yeniden kümeleme işlemine sokulur ve en büyük ikinci değere sahip olan kök olur. Bu değer de dizinin sondan ikinci elemanı ile yer değiştirilir. Bu aşamada en büyük ikinci değer, en büyük değerin önüne yerleştirilmiş olur. Daha sonra benzer işlemler (n-2),(n-3) elemanlı dizi için yapılır ve dizi adım adım sıralanır.
2.5-Kümeleme(Heap) Sıralama /*Kaba kodu*/ kumelemesiramalasi(a) { Kumelemeagaciolustur(A); for(k=elemansayisi(a)-1;k>1;k--) { kok=a[0]; Kok ile A[k] yı yer değiştir; agacikumele(a,1);
2.6-Hızlı Sıralama Hızlı sıralama algoritması böl ve yönet mantığına dayanır; sıralanması istenen dizi belirli bir sınır değerine göre iki alt diziye ayrılır. Sınır sayısından küçük olan elemanlar bir tarafa, büyük olan elemanlar diğer tarafa toplanır. Daha sonra yine hızlı sıralama algoritması kullanılarak, bu iki alt dizinin sıralanması istenir. Örnek: A={5,9,6,7,3,1,8, Sınır değer 6 olsun. o A1={2,5,3,1 ve A2={9,7,8. o Bu diziler tekrar sınır değer seçilerek ikiye bölünür. Bu işlem dizi parçalanmayacak duruma gelene kadar devam eder. Fonksiyon 3 farklı parametre gerektirir. Biri diziyi içeren değişken, diğerleri de dizinin sıralamaya koyulacak parçasının sol ve sağ taraflarının indisi.
2.6-Hızlı Sıralama Algoritma ilk çağrıldığında, n elemanlı bir dizi için sol=0, sag=n-1 olur. Rekürsif çağırmalar sırasında sol değer büyürken sağ değer küçülecektir. Ne zaman ki sol değeri sağ değerden büyük olursa dizide bölünecek eleman kalmadığı anlaşılmış olur. Hızlı sıralama algoritmasının en kötü durumdaki zaman karmaşıklığı O(n 2 ) dir. Ancak ortalama zaman karmaşıklığı O(nlog 2 n) çıkmaktadır.
hsirala(int dizi[], int sol, int sag) { register int k, j; int ortadaki, gecici; /* Diziyi ikiye parçalama kısmı */ k=sol; j=sag; ortadaki=dizi[(sol+sag)/2)]; /* sınır değer */ do { while(dizi[k] < ortadaki && k<sag ) k++; while(ortadaki < dizi[j] && j>sol) j--; if( k<=j ) { gecici=dizi[k]; dizi[k]=dizi[j]; dizi[j]=gecici; k++; j--; while( k<=j ); /* parçalama bitti */ if( sol<j ) hsirala(dizi, sol, j); if( k<sag ) hsirala(dizi, k, sag);
Herhangi bir sayı seçilir ve geri kalan sayılar arasından küçük olanlar sayının soluna büyük olanlar sayının sağına getirilerek sıralama tamamlanır.
2.7-Turnuva Sıralaması
2.7-Turnuva Sıralaması