Anlaşılması en kolay algoritmalardan bir tanesidir. Zaten kodunu okuyunca ne kadar basit olduğunu anlayacaksınız. Ben yine de her bir kod işleminin çıktısını resimlerle göstermeye çalıştım.

Bu algoritmada dizinin bir ucundan başlanır. Diğer uçtaki eleman sıralama için seçilen ilk değerdir. Bir ucundan diğer ucuna doğru her eleman için seçilen değer ile karşılaştırma yapılır. Eğer dizi elemanı seçilen değere göre aranan ise dizi elemanı, yeni seçilen değer olur. Dizinin kalan elemanları yeni seçilen değer ile karşılaştırılır.

Örneğin bir sayı dizisinde dizinin başından sonuna doğru küçükten büyüğe sıralama yapılmak istensin. Her döngüde dizinin sonundaki eleman, en küçük sayı kabul edilir. Dizinin başından sonuna kadar (son eleman hariç) tüm sayılar en küçük sayı ile karşılaştırılır. Eğer karşılaştırılan sayı daha küçükse artık bu dizi elemanı en küçük kabul edilir. Dizinin sonuna gelince dizinin ilk elemanı ile en küçük kabul edilen eleman yer değiştirir. Sonra dizinin 2 elemanından başlanarak aynı yöntem uygulanır. Eleman sayısının bir eksiği kadar bu döngü tekrarlanmış olur. Sonunda dizi sıralanmış olur.

Bazılarına göre bu algoritmanın tek bir olumlu yanı var . Eğer elaman gerçek yerinde ise yer değiştirme işlemine gerek olmaması. Kümenin karışıklığına göre bu fikir değişir. Bu durumu beklemek tabiki manasız. Ancak bazı durumlarda kümenin böyle bir durumda olduğunu öngörebilirsiniz. Örneğin elimizde sıralı bir dizi olsun. Biliyoruz ki bazı küçük işlemler dizinin sırasını bir miktar bozuyor. Bu dizinin sıralaması için bu algoritmayı kullanılabiliriz.

Basit bir kod parçası ile göstermek gerekirse;

Yukarıdaki örnekte bahsedildiği üzere algoritmanın gerçekleşmesi için 2 adet döngüye ihtiyaç vardır.

int[]? dizi = null;
if (!isValid(out dizi))
    return;

if (dizi == null) return;

int enkucuk;
int index;

//1. elemanından başlıyoruz.
for (int i = 0; i <= (dizi.Length - 1); i++)
{
    //son eleman en küçük kabul edilir.
    enkucuk = dizi[dizi.Length - 1];
    index = dizi.Length - 1;

    for (int j = i; j < (dizi.Length - 1); j++)//daha küçüğü aranır
    {
        if (dizi[j] < enkucuk)
        {
            enkucuk = dizi[j];
            index = j;
        }
    }
    dizi[index] = dizi[i];
    dizi[i] = enkucuk;
}

Sıralanması nı istediğimiz dizi “9 4 5 3 2 1 8 6 7” olsun.

Dizimizin ilk hali 

Her bir döngü için program çıktısı aşağıdaki resimlerde gösterildiği gibi olur.

Örnek uygulamaya aşağıdaki link ile erişebilirsiniz.

https://github.com/ahmetozgunozcan/SortingAlgorithms

Merge sort böl ve yönet yaklaşımına dayanır. Sürekli dizinin ortadan ikiye bölünmesi ile yürütülür. Bu davranışı rekürsif tasarlanabileceğini gösterir. Her parçalama işlemi ile oluşan kümeler aynı yöntem ile parçalanır. Yani alt kümede 1 adet eleman kalıncaya kadar 2 adet parçalara bölünür. Bir adet eleman kalınca da rekürsif dönüşler başlar.  Geriye dönüşlerde alt küme elemanlarının sıralanması işlemi yapılır. Her geri dönüşte alt küme üst küme ile birleştirilir. Algoritma adını bu birleştirme işleminden almıştır.

Basit bir kod parçası ile göstermek gerekirse;

bol(Dizi[],sol,sag)
{
   if(sol<sag)                       
   {
      int orta=(sol+sag)/2;
      bol(D,sol,orta);
      bol(D,orta+1,sag);
      birlestir(D,sol,orta,sag);
   }
}

Yukarıdaki kod örneğine göre algoritma basit gibi görünse de geçekleştirilmesi diğer sıralama algoritmalarına göre daha karmaşıktır.

Sıralanmak istenen elemanlar bir dizi ile tutuluyorsa parçalamak kolay, birleştirilmesi zordur. Bağlı listede tutuluyorsa parçalanması zor, birleştirilmesi kolaydır. Dizi üzerinde tutulan parçaların birleştirilmesi için ek dizi alanlarına ihtiyaç vardır. Bağlı listede de orta elemana doğrudan erişim olmadığı için parçalamada zaman maliyeti fazla olur. Eğer eleman sayısı biliniyorsa N/2 çevrim yapılır.

Dizi bazlı veri setinde;

Heap Sort algoritması Merge Sort algoritmasına göre daha az bellek kullanır ve daha hızlı çalışır. Aynı şekilde bellek tabanlı dizi kullanımında Quick Sort algoritması daha hızlı çalışır.

Bağlı listelerde;

Bağlı listelerde sıralama yapılmak istenirse Merge Sort algoritması seçilebilir. Çünkü performans açısından daha iyi olabilmektedir. Heap Sort algoritmasının kullanımı imkansızdır. Quick Sort için ise performansın düşmesin beklenir.

Sıralanması nı istediğimiz dizi “9 4 5 3 2 1 8 6 7” olsun.

Dizimizin ilk hali 

Aşağıda adım adım işlemler sıralanmaktadır. her bir düngüde mavi kutucuklar karşılaştırılan sayıları göstermektedir. yeşil kutucuklar ise yer değiştirme sonrası halini göstermektedir. Kırmızı kutular ise yerini bulmuş elemanı gösterir.

class MergeSort
    {
        int[] dizi;
        public MergeSort(int[] dizi)
        {
            this.dizi = dizi;
        }

        public int[] Sort()
        {
            Sort(0, dizi.Length - 1);

            return dizi;
        }

        private void Sort(int sol, int sag)
        {
            if (sol < sag)//Eleman sayısı 1 den büyük ise
            {

                //orta indexi bul
                int orta = (sol + sag) / 2;

                //Sol kümeyi böl sırala
                Sort(sol, orta);

                //Sağ kümeyi böl sırala
                Sort(orta + 1, sag);

                Birlestir(sol, orta, sag);//Bölüp sıraladıklarını birleştir.
            }
        }

        private void Birlestir(int sol, int orta, int sag)
        {
            int solElemanSayisi = orta - sol + 1;
            int sagElemanSayisi = sag - orta;

            int[] SOL = new int[solElemanSayisi];
            int[] SAG = new int[sagElemanSayisi];

            for (int t = 0; t < solElemanSayisi; ++t)
                SOL[t] = dizi[sol + t];

            for (int z = 0; z < sagElemanSayisi; ++z)
                SAG[z] = dizi[orta + 1 + z];

            int i = 0, j = 0;
            int k = sol;
            while (i < solElemanSayisi && j < sagElemanSayisi)
            {
                //Soldaki sayi sağdakinden küçük eşitse diziye önce onu koy.
                if (SOL[i] <= SAG[j])
                {
                    dizi[k] = SOL[i];
                    i++;
                }

                //Sağdaki sayi soldakinden küçük eşitse diziye önce onu koy.
                else
                {
                    dizi[k] = SAG[j];
                    j++;
                }
                k++;
            }

            //SOL da kalanları diziye ekle
            while (i < solElemanSayisi)
            {
                dizi[k] = SOL[i];
                i++;
                k++;
            }

            //SAĞ da kalanları diziye ekle
            while (j < sagElemanSayisi)
            {
                dizi[k] = SAG[j];
                j++;
                k++;
            }

        }
    }

Örnek uygulamaya aşağıdaki link ile erişebilirsiniz.

https://github.com/ahmetozgunozcan/SortingAlgorithms

Ardışıl Arama (Sequential Search), en yalın arama yöntemidir. Bir veri seti içerisinde aranan veriyi bulmak amacıyla baştan sona doğru  yapılan tarama işlemidir. Kodlaması çok basittir ancak çalışma hızı çok düşüktür.  Genelde ikili arama algoritmaları yaygın olarak kullanılır.

Bir çok arama algoritmasında aşağıdaki üç husus dikkate alınır.

• Bellek kullanımı
• Geçen zaman
• Algoritmanın okunurluğu

Veri setinin büyüklüğü,modeli ve arama işleminin gerçekleştirileceği ortama göre bu 3 hususta öncelik değişkenlik gösterir.

Şimdi arama algoritmalarında kullanılan bazı kavramlardan bahsedelim. Ayrıca veri seti önceden sıralı ise arama işlemi daha basit olacaktır ya da arama algoritması değişiklik gösterecektir.

Anahtar Sözcük (Keyword): Arama işlemi belli bir veya birkaç bilgi için gerçekleştirilir. Bu bilgi parçası bir sayısal veri, cümle, tarih, vb. olabileceği gibi tüm bunların biraraya gelmesinden de oluşabilir. Anahtar sözcükler genelde küçük ve sadedirler. Küçüklük ve sadelikleri aksi yönde değiştikçe algoritmaların sonuç üretmesi de zorlaşacak ve zaman alacaktır.

Harici Arama( External Search): Arama işleminin gerçekleştirileceği veri seti eğer bir disk/disket/ usb/ cd ve harici bir saklama biriminde tutuluyor ise bu verinin arama işlemine harici arama denir.

Dahili Arama( internal Search): Arama işleminin gerçekleştirileceği veri seti RAM gibi erişimi çok hızlı belleklerde tutuluyor ise bu verinin arama işlemine dahili arama denir.

Yukarıda tanımını yaptığım harici ve dahili arama, algoritmanın seçimini en çok etkileyen özelliklerden bir tanesidir. Harici arama işlemlerinde verilerin yer değişiminin az olmasını sağlayan algoritmalar seçilir. Çünkü harici depolama birimlerinde bu işlemler daha yavaş olacaktır. Kullanacağınız arama algoritması ne kadar hızlı olursa olsun çok fazla yer değişimi yapıyor ise yavaş işlem yapacağından olumlu sonuç alamayacaksınız. Dahili arama işlemlerinde ise verinin bellekte tutulamayacak kadar büyük olmaması gerekir.

Birincil Anahtar Sözcük: Anahtar sözcüğün aldığı değerin her kayıt için farklı olmasıdır. Birincil anahtar sözcük bir veri setinde aranırken ilk bulunduğu yerde arama algoritması tamamlanır. Diğer veri öğelerine bakılmaz.

İkincil Anahtar Sözcük: Farklı kayıtlar için aynı anahtar sözcüğün kullanılmasıdır. İkincil anahtar sözcük bir veri setinde aranırken tüm veri setinde arama algoritması tamamlanır.

Örneğin bir personel uygulamasında T.C. Kimlik Numarası birincil anahtar sözcüktür. Ancak personel adı ikincil anahtar sözcüktür.

Ayrıca arama algoritmalarını hızlandırmak adına bir çok düzenlemeler mevcuttur. Veri tabanında kullanılan indexler, konsolide edilmiş datalar bunlara örnektir.

Arama algoritmaları 3 temel sınıfta toplanır.Bunlar;

1. İkili Arama
2. Bir Çırpıda Arama
3. Doğrusal Arama

Temel olan, karışık düzende verilmiş bir dizide   elemanlar içerisinde ilerlerken komşu iki elemanın birbiri ile yer değiştirmesidir. Her adımda komşu iki eleman karşılaştırılır, gerekirse yer değiştirilir.  Bu algoritma iki döngü ile yapılır. İlk döngü elemanlar arasında geçişi, diğer döngü ise yerleştirme işlemi içindir. Bu algoritmanın zaman karmaşıklığı O(n²) dir.  Eğer dizide x kadar eleman sıralı değilse, zaman karmaşıklığı ise  O(xn) dir. Kodlaması oldukça basit olmasına rağmen etkin bir algoritma değildir. Belki geneli sıralı olan dizileri düzeltmek için ve eleman sayısı çok olmayan diziler için kullanılabilir.

Ayrıca bir kaydırma işlemi olması sebebi ile harici bir sıralama yapılırken çok fazla yazma ve okuma işlemi olacağından maliyetli bir algoritmadır. 

Sıralanması nı istediğimiz dizi “9 4 5 3 2 1 8 6 7” olsun.

Dizimizin ilk hali 

Aşağıda adım adım işlemler sıralanmaktadır. her bir düngüde mavi kutucuklar karşılaştırılan sayıları göstermektedir. yeşil kutucuklar ise yer değiştirme sonrası halini göstermektedir. Kırmızı kutular ise yerini bulmuş elemanı gösterir.

1. Döngü

1. ADIM:	2. ADIM:
3. ADIM:	4. ADIM:
5. ADIM:	6. ADIM:
7. ADIM:	8. ADIM:

Sonucu :

2. Döngü

1. ADIM:	2. ADIM:
3. ADIM:	4. ADIM:
5. ADIM:	6. ADIM:
7. ADIM:

Sonucu :

3. Döngü

1. ADIM:	2. ADIM:
3. ADIM:	4. ADIM:
5. ADIM:	6. ADIM:

Sonucu :

4. Döngü

1. ADIM:	2. ADIM:
3. ADIM:	4. ADIM:
5. ADIM:

Sonucu :

5. Döngü

1. ADIM:	2. ADIM:
3. ADIM:	4. ADIM:

Sonucu :

6. Döngü

1. ADIM:	2. ADIM:
3. ADIM:

Sonucu :

7. Döngü

1. ADIM:

2. ADIM:

Sonucu :

8. Döngü

1. ADIM:

Sonucu :

private static void bubblesort(int[] array)
       {
           //eleman sayısı
           var n = array.Length;
           //Ana döngüyü oluşturuyoruz.
           //dizinin eleman sayısının 1 eksiği kadar döngü gerçekleşmeli.
           for (int dongu = 0; dongu < (n - 1); dongu++)
           {
               //her düngüde 1 eleman yerleşeceği için adım sayısı önceki döngüye göre 1 eksik olmalıdır.
               for (int i = 0; i < n - 1 - dongu; i++)
               {
                   var e1 = array[i];
                   var e2 = array[i + 1];
                   //sıralı ise bir sonraki adıma geç.
                   if (e1 <= e2)
                       continue;
                   //sıralı değilse yer değiştir.  
                   array[i] = e2;
                   array[i + 1] = e1;
               }
           }
       }

Örnek uygulamaya aşağıdaki link ile erişebilirsiniz.

https://github.com/ahmetozgunozcan/SortingAlgorithms

Karışık düzende verilmiş bir dizide ilk sıradan başlamak üzere her bir değeri olması gereken yere yerleştirme şeklinde çalışır. Sıralanacak veri setinin ilk elemanının yerinde bırakılması ve sırayla sonraki elemanların teker teker alınıp öncekilerin diziliminde uygun olacak yere konulması ile yapılan işlemdir. İlk eleman kendi yerinde bırakılır. Sonrasında ikinci eleman birincisi ile karşılaştırılarak önüne veya ardına yerleştirilir. Sonraki eleman alınır. Sıralanmış dizi içerisinde uygun olan yere ( en öne, aralarına veya en sona) yerleştirilir. Bu işlem tüm elemanlar için gerçekleştirilerek sıralama işlemi yapılır.

Şöyle ki, sıralanacak olan dizi iki parçaya bölünür. Bir taraf sıralı parçadır. Diğer taraf ise sırasız parçadır.  Programlaması oldukça basit bir algoritmadır. Ancak performans açısında çok hızlı olduğu söylenemez. Çünkü sıralanmış kısımda araya sokulacak elemanın yerini bulma ve kalanları kaydırma işlemleri gerekir. n elemanlı karışık bir dizinin çözümü n-1 adımda gerçekleşir. Aslında bu algoritma sıralı olan herhangi bir dizi içerisine  sıralı olma durumunu bozmadan yeni elemanlar eklemek için uygundur. Sıralı bir dizide bu algoritma ile yeni bir eleman eklemenin zaman karmaşıklığı O(n) dir. Sıralı olmayan bir dizide bu algoritma ile yeni bir eleman eklemenin zaman karmaşıklığı ise  O(n²) dir.

Sıralanması nı istediğimiz dizi “9 4 5 3 2 1 8 6 7” olsun.

Dizimizin ilk hali 

Aşağıda adım adım işlemler sıralanmaktadır.

1.Adım

Araya Sokulacak Eleman: 9 9 rakamı ilk eleman olduğu için olduğu yerde bırakıyoruz.

 

 

 

2.Adım

Araya Sokulacak Eleman: 4
4 sayısı için uygun yeri arıyoruz. 4 sayısı 9 un yerine geçmelidir. Bu nedenle 9 ve 9’dan sonraki tüm sıralanmış elemanlar bir adım sağa doğru boşluğu dolduracak şekilde ilerletilir. 4 sayısı boşalan yere geçer.

3.Adım

Araya Sokulacak Eleman: 5
5 sayısı için uygun yeri arıyoruz. 5 sayısı 9 un yerine geçmelidir. Bu nedenle 9 ve 9’dan sonraki tüm sıralanmış elemanlar bir adım sağa doğru boşluğu dolduracak şekilde ilerletilir. 5 sayısı boşalan yere geçer.

4.Adım

Araya Sokulacak Eleman: 3
3 sayısı için uygun yeri arıyoruz. 3 sayısı 4 un yerine geçmelidir. Bu nedenle 4 ve 4’ten sonraki tüm sıralanmış elemanlar bir adım sağa doğru boşluğu dolduracak şekilde ilerletilir. 3 sayısı boşalan yere geçer.

5.Adım

Araya Sokulacak Eleman: 2
2 sayısı için uygun yeri arıyoruz. 2 sayısı 3 ün yerine geçmelidir. Bu nedenle 3 ve 3’ten sonraki tüm sıralanmış elemanlar bir adım sağa doğru boşluğu dolduracak şekilde ilerletilir. 2 sayısı boşalan yere geçer.

6.Adım

Araya Sokulacak Eleman: 1
1 sayısı için uygun yeri arıyoruz. 1 sayısı 2 nin yerine geçmelidir. Bu nedenle 2 ve 2’den sonraki tüm sıralanmış elemanlar bir adım sağa doğru boşluğu dolduracak şekilde ilerletilir. 1 sayısı boşalan yere geçer.

7.Adım

Araya Sokulacak Eleman: 8
8 sayısı için uygun yeri arıyoruz. 8 sayısı 9 un yerine geçmelidir. Bu nedenle 9 ve 9’dan sonraki tüm sıralanmış elemanlar bir adım sağa doğru boşluğu dolduracak şekilde ilerletilir. 9 sayısı boşalan yere geçer.

8.Adım

Araya Sokulacak Eleman: 6
6 sayısı için uygun yeri arıyoruz. 6 sayısı 8 nin yerine geçmelidir. Bu nedenle 8 ve 8’den sonraki tüm sıralanmış elemanlar bir adım sağa doğru boşluğu dolduracak şekilde ilerletilir. 6 sayısı boşalan yere geçer.

9.Adım

Araya Sokulacak Eleman: 7
7 sayısı için uygun yeri arıyoruz. 7 sayısı 8 nin yerine geçmelidir. Bu nedenle 8 ve 8’den sonraki tüm sıralanmış elemanlar bir adım sağa doğru boşluğu dolduracak şekilde ilerletilir. 7 sayısı boşalan yere geçer.

private static void insertionSort(int[] array)
{
    //dizinin ilk elemanını yerinde bıraktık.

    //2. elemanından başlıyoruz.
    for (int i = 1; i <= (array.Length - 1); i++)
    {
        //araya sokacağımız veriyi tutuyoruz.
        var current = array[i];

        //hangi indexte bulunduğumuzu tutuyoruz.
        int currentRealIndex = i;

        //sola doğru yani sıralanmış kayıtlar arasında tarama yapıyoruz.
        //Sayımızın büyük olduğu elemana kadar ilerleyip araya sokacağımız index değerini buluyoruz.
        for (int j = i - 1; j >= 0 && currentRealIndex>0; j--)
        {
            if (array[j] < current)
                break;

            currentRealIndex--;
        }

        //araya sokulacak indexten sonraki tüm elemanları bir adım sağa kaydırıyoruz.
        for (int j = i; j > currentRealIndex; j--)
        {
            array[j] = array[j - 1];
        }

        //araya elemanımızı yerleştiriyoruz.
        array[currentRealIndex] = current;
    }
}

Örnek uygulamaya aşağıdaki link ile erişebilirsiniz.

https://github.com/ahmetozgunozcan/SortingAlgorithms

Anahtar Sözcük (Keyword): Sıralama işleminin gerçekleştirilmesi için bir bilgi parçasına ihtiyacı vardır. Bu bilgi parçası bir sayısal veri, cümle, tarih, vb. olabileceği gibi tüm bunların biraraya gelmesinden de oluşabilir. Anahtar sözcükler genelde küçük ve sadedirler. Küçüklük ve sadelikleri aksi yönde değiştikçe algoritmaların sonuç üretmesi de zorlaşacak ve zaman alacaktır.

Harici Sıralama( External Sorting): Sıralanmak istenen veri eğer bir disk/disket/ usb/ cd ve harici bir saklama biriminde tutuluyor ise bu verinin sıralama işlemine harici sıralama denir.

Dahili Sıralama( internal Sorting): Sıralanmak istenen veri RAM gibi erişimi çok hızlı belleklerde tutuluyor ise bu verinin sıralama işlemine dahili sıralama denir.

Yukarıda tanımını yaptığım harici ve dahili sıralama, algoritmanın seçimini en çok etkileyen özelliklerden bir tanesidir. Harici sıralama işlemlerinde verilerin yer değişiminin az olmasını sağlayan algoritmalar seçilir. Çünkü harici depolama birimlerinde bu işlemler daha yavaş olacaktır. Kullanacağınız sıralama algoritması ne kadar hızlı olursa olsun çok fazla yer değişimi yapıyor ise yavaş işlem yapacağından olumlu sonuç alamayacaksınız. Dahili sıralama işlemlerinde ise verinin bellekte tutulamayacak kadar büyük olmaması gerekir.

İndexleme(indexed file structure): Dizinli dosya yapısı da denilebilir. Verilerin çok büyük olduğu kümelerde verileri sıralamakla uğraşılmaz. Bunun yerine her bir veriye tekil bir anahtar numarası verilir. Asıl verilerin yerleşimlerinde kesinlikle bir sıralama yapılmaz. Bunun yerine anahtar numaraları ve özellikleri kullanılarak sıralama yapılır. Özetle gerçek veriler harici/daha yavaş depolama birimlerinde sırası bir şekilde tutulurken anahtarları dahili yani bellekte sıralanırlar. Herhangi bir veriye ulaşılmak istendiğinde indexlenmiş anahtar kümesinden dosyanın yoluna ulaşılır ve dosya harici depolamadan kolaylıkla okunur.

• Yürütme Zamanı
• Gereken Bellek Alanı

Yürütme zamanı algoritmanın geliştirildiği kod parçası ve sıralama işleminin hangi fiziksel ortamda yapıldığına bağlıdır. Gerekli bellek alanı ise kullanılacak algoritma ile belli olur.

Şimdi arkadaşlar sıralama algoritmalarının zaman karmaşıklıklarını, uygulandığı veri modelini ve uygun olduğu bellek ortamını aşağıdaki tabloda paylaştım.

Örnek uygulamaya aşağıdaki link ile erişebilirsiniz.

https://github.com/ahmetozgunozcan/SortingAlgorithms