Hızlı sıralama - Quick Sort

  Hızlı(Quick sort) sıralama algoritması çok hızlı algoritmalardan birisidir. Sadece eğitim amaçlı değil programların içerisinde de sıralama için kullanılmaktadır. Algoritma çok basittir ve yerinde sıralama yapar yani tek dizi üzerinde elemanların yerlerini değiştirerek işlem yapar. Böyle olması da zaman açısından ve alan açısından hız demektir.

Algoritmanın çalışma mantığı
  Sayı dizisinden herhangi bir sayıyı dayanak eleman(pivot) eleman olarak seç.
  Sayı dizisini dayanak elemandan(pivot) küçük olan tüm sayılar dayanak elemanın(pivot) önüne, dayanak elemandan(pivot) büyük olan tüm sayılar dayanak elemanın(pivot)  arkasına gelecek biçimde düzenle (dayanak elemana eşit olan sayılar her iki yana da geçebilir).
  Bu bölümlendirme işleminden sonra eleman sıralanmış son dizide olması gerektiği yere gelir. Algoritmanın bu aşamasına bölümlendirme aşaması denir.
  Dayanak elemanın sol ve sağ yanında olmak üzere oluşan iki ayrı küçük sayı dizisi, hızlı sıralama algoritması bu küçük parçalar üzerinde yeniden özyineli olarak çağrılarak sıralanır.

Algoritmanın karmaşıklığı
Hızlı sıralama algoritması n adet sayıyı, ortalama bir durumda, {O}(nlog(n)) karmaşıklığıyla, en kötü durumda ise {O}(n^2) karmaşıklığıyla sıralar.

Hızlı sıralama algoritması java kodları

 public static void hizliSiralama(int dizi[], int sol, int sag) {
  int indis = parca(dizi, sol, sag);
  if (sol < indis - 1) {
   hizliSiralama(dizi, sol, indis - 1);
  }
  if (indis < sag) {
   hizliSiralama(dizi, indis, sag);
  }
 }

 public static int parca(int dizi[], int sol, int sag) {
  int i = sol, j = sag;
  int gecici;
  int dayanakEleman = dizi[(sol + sag) / 2];

  while (i <= j) {
   
   //soldan başlayarak dayanak elemanı(pivot)tan küçük elemanı bul
   while (dizi[i] < dayanakEleman) {
    i++;
   }
   //sağdan başlayarak dayanak elemanı(pivot)tan büyük elemanı bul
   while (dizi[j] > dayanakEleman) {
    j--;
   }
   //bulunan elamanların yerlerini değiştir
   if (i <= j) {
    gecici = dizi[i];
    dizi[i] = dizi[j];
    dizi[j] = gecici;
    i++;
    j--;
   }
  };

  return i;
 }

Kodlara ulaşmak için github adresine gidin

Birleştirmeli Sıralama - Merge Sort

  Merge sort (bireşen sıralama), diziyi ardışık olarak en küçük alt dizilerine kadar yarılayan sonra da onları sıraya koyarak bireştiren özyineli bir algoritmadır. Yarılama işlemi en büyük alt dizi en çok iki öğeli olana kadar sürer. Sonra merge (bireşim) işlemiyle altdiziler ikişer ikişer bölünüş sırasıyla sıralı olarak bir üst dizide bireşir. Süreç sonunda en üstte sıralı diziye ulaşılır.

Algoritmanın çalışma mantığı şu şekildedir. 
  Sıralı olmayan listeyi ortadan eşit olarak iki alt listeye ayırır.
  Alt listeleri kendi içinde sıralar.
  Sıralı iki alt listeyi tek bir sıralı liste olacak şekilde birleştirir.

Algoritmanın karmaşıklığı 
  Birleştirme sıralaması böl ve yönet algoritmasına güzel bir örnektir. Birleştirme sıralamasının karmaşıklığını hesaplamak için sıralanacak N elemanlı diziyi bir ağaç yapısına taşıyınca her bir düğüm bir alt diziyi temsil eder.
  Ağaç tam olarak n seviye içerir. k sayısı 0'dan n-1'e kadar ağaç seviyesini temsil etsin, yukarıdan aşağıya doğru ağacın k. seviyesinde 2^k tane düğüm bulunur. Bu düğümlerin her biri 2^{n-k}uzunluğunda bir alt diziyi temsil eder.
  Bir alt dizinin eleman sayısı 2^{n-k} olduğu için en fazla 2^{n-k} karşılaştırma yapılabilir. Ağacın her seviyesindeki alt dizi sayısı ve yapılabilecek en fazla karşılaştırma sayısı2^k . 2^{n-k} = 2^n ' dır. n seviye ağaç için toplam n . 2^n karşılaştırma yapılır. Elde edilen n . 2^n değerinin asimptotik üst sınırı O(NlgN) değeridir.

 Birleştirmeli sıralama algoritması java kodları

 public static void birlestirmeliSiralama(int alt, int üst,int[] sirasizDizi) {
  if (alt < üst) {
   int orta = (alt + üst) / 2;
   //sirasiz dizimi yerel değişken yaptığımdan diziyide metodlara yolladım
   birlestirmeliSiralama(alt, orta, sirasizDizi); 
   birlestirmeliSiralama(orta + 1, üst,sirasizDizi);
   birlestir(alt, orta, üst,sirasizDizi);
  }
 }

 public static void birlestir(int alt, int orta, int üst,int[] sirasizDizi) {
  int[] yedekDizi = new int[sirasizDizi.length];
  int i, j, k;
// a dizisinin her iki yarısını yedekDizi dizinine kopyala
  for (i = alt; i <= üst; i++) {
   yedekDizi[i] = sirasizDizi[i];
  }
  i = alt;
  j = orta + 1;
  k = alt;
  // her adımda bir sonraki en büyük terimi kopyala
  while (i <= orta && j <= üst) {
   if (yedekDizi[i] <= yedekDizi[j]) {
    sirasizDizi[k++] = yedekDizi[i++];
   } else {
    sirasizDizi[k++] = yedekDizi[j++];
   }
  }
// varsa, ilk yarıdan arta kalan terimlerin hepsini kopyala
  while (i <= orta) {
   sirasizDizi[k++] = yedekDizi[i++];
  }
 }

Kodlara ulaşmak için github adresine gidin

Eklemeli Sıralama - Insertion Sort

Eklemeli sıralama algoritması diziyi her adımda öğe öğe oluşturan bir sıralama algoritmasıdır.
Küçük Veri kümeleri üzerinde kullanıldığında verimlidir.Çoğunluğu zaten sıralanmış olan diziler üzerinde kullanıldığında verimlidir.
Sıralanacak diziyi yerinde sıralar, ek bir bellek alanı gerektirmez.

Algoritmanın çalışma mantığı şu şekildedir.
Geçici olarak atanan dizi elemanının yerini bulunup oraya koyulması üzerine çalışır.Yeri bulmak için
dizi içerisinde geçici elemanın bulunduğu yerden başa doğru kaydırma işlemi yapılmaktadır.

Algoritmanın karmaşıklığı
En kötü başarım: Eklemeli sıralama algoritması en kötü durumda, örneğin liste tersten sıralıysa O(n^2) karmaşıklıkla çalışır.
En iyi başarım: Eklemeli sıralama algoritması en iyi durumda, örneğin liste sıralıysa sadece  n-1 karşılaştırma yapar ve
 O(n) karmaşıklıkla çalışır.
Ortalama başarım: Eklemeli sıralama algoritması ortalama O(n^2) karmaşıklıkla çalışır.

Örnek
1.(5 1 4 2 8 ) \to ( 1 5 4 2 8 )
gecici = 1 olur j=0 olur 1-5 karşılaştırılıp 5 bir sağ kaydırılıp 1 j'ye koyulur
2.(1 5 4 2 8 ) \to ( 1 4 5 2 8 )
gecici = 4 olur j=1 olur 4-5 karşılaştırılıp 5 bir sağ kaydırılıp 4 j'ye koyulur
3.(1 4 5 2 8 ) \to ( 1 2 4 5 8 )
gecici = 2 olur 2-5 sonra 2-4 karşılaştırılıp 4 ve 5 bir sağ kaydırılır
her kaydırma için j bir azaltılır ve 2 j'ye koyulur
4.( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
sıralı olduğundan değişim yapılmaz

Eklemeli sıralama algoritması java kodları

public static void eklemeliSiralama(int[] dizi) {
  int gecici = 0, j = 0;
  
  for (int i = 1; i < dizi.length; i++) {
   gecici = dizi[i]; // i. eleman gecici yapıyoruz   
   j = i - 1; //i nin bir eksiğini j ye atıyoruz
   
   // j sıfırdan büyükse ve
   //  geçici, dizinin j. elamanından küçük olana kadar kaydırma yap
   while (j >= 0 && gecici < dizi[j]) {
    dizi[j + 1] = dizi[j];
    j = j - 1;
    dizi[j + 1] = gecici;
   }

  }
 }

Kodlara ulaşmak için github adresine gidin

Seçmeli Sıralama - Selection Sort

Seçmeli sıralama algoritması, küçük boyutlu dizileri sıralarken veya dizinin bir bölümü sıralı ise yer değiştirme işlemi yapılmadığı için tercih edilir.

Algoritmanın çalışma mantığı şu şekildedir.

1.Listedeki en küçük değerli öğeyi bul.
2.İlk konumdaki öğeyle bulunan en küçük değerli öğenin yerini değiştir.
3.Yukarıdaki adımları listenin ilk elemanından sonrası için (ikinci elemandan başlayarak) yinele.

Algoritmanın karmaşıklığı
Seçmeli sıralama algoritması listenin en küçük elemanının nerede olduğunu bilmediği ve her bir eleman için tüm elemanlarla karşılaştırma yaptığı için liste içindeki elemanların rastgele sıralanmış ya da eşit elemanlardan oluşmasını dikkate almaz, bu sebeple seçmeli sıralama algoritması her durumda O(n^2) karmaşıklığıyla çalışır.

Örnek:

1. ( 5 1 4 2 8 ) \to ( 1 5 4 2 8 )

i=0 minIndis=0 (5 değeri) ile baslar j=1 (1 değeri) en küçük olduğundan minIndis=1 olur değiştiririz.

2.( 1 5 4 2 8 ) \to ( 1 2 4 5 8 )

i=1 minIndis=1 (5 değeri) ile baslar j=3 (2 değeri) en küçük olduğundan minIndis=3 olur değiştiririz.

3.( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )

Döngümüz devam edecektir ama sıralama işlemi bu adımda bitti.

Seçmeli sıralama algoritması java kodları

 public static void secmeliSiralama(int[] dizi) {
  int yedek;
  int minIndis;
  
  for (int i = 0; i < dizi.length; i++) {
   minIndis = i;
   //Son indisten başlayarak karşılaştırmaya devam ediyoruz
   for (int j = i; j < dizi.length; j++) {
    //minIndis den daha küçük değer varsa indisi değiştiriyoruz
    if (dizi[j] < dizi[minIndis]) {
     minIndis = j;
    }
   }
   //burada değiştirme işlemini yapıyoruz
   yedek = dizi[i];
   dizi[i] = dizi[minIndis];
   dizi[minIndis] = yedek;
  }

 }

Kodlara ulaşmak için github adresine gidin

Kabarcık Sıralama - Bubble Sort

     Bu yazımızda kabarcık sıralama (Bubble Sort) algoritmasını inceleyeceğiz.Öncelikle kabarcık sıralama algoritması hakkında bilgi verelim.Adına kabarcık sıralaması denmesinin nedeni büyük olan sayıların aynı suyun altındaki bir kabarcık gibi dizinin üstüne doğru ilerlemesidir.

Algoritmanın çalışma mantığı şu şekildedir.
     Kabarcık sıralaması dizinin başından başlar ve dizi elemanlarını sırayla seçer. Seçilen dizi elemanı kendinden sonra gelen elemandan büyükse bu iki elemanın yerleri değiştirilir. Bu işlem sonucunda dizinin en büyük elemanı dizi sonuna yerleştirildiğinden bir sonraki adımda arama sınırı bir eleman geri çekilir. Bu işlem, dizinin sonundaki elemanın karşılaştırılmasına kadar yinelenerek sürdürülür.

Algoritmanın karmaşıklığı
     Kabarcık sıralama algoritmasının ortalama ve en kötü durumdaki karmaşıklığı {O}(n^2)'dir. Algoritma ortalama ve en kötü durumda (n^2) / 2 adet karşılaştırma ve yer değiştirme gerçekleştirir.

Algoritmanın işleyişi
     İçeriği "5 1 4 2 8" olan bir dizi kabarcık sıralaması ile en küçükten en büyüğe doğru aşağıdaki biçimde sıralanır. Her adımda dizinin kalın olarak işaretlenmiş elemenları karşılaştırılan elemanlardır.

Birinci Geçiş:
( 5 1 4 2 8 ) \to ( 1 5 4 2 8 ) İlk iki elemanı karşılaştırır ve yerlerini değiştirir.
( 1 5 4 2 8 ) \to ( 1 4 5 2 8 )
( 1 4 5 2 8 ) \to ( 1 4 2 5 8 )
( 1 4 2 5 8 ) \to ( 1 4 2 5 8 ) Elemanlar zaten sıralı olduğu için algoritma yerlerini değiştirmez.
İkinci Geçiş:
( 1 4 2 5 8 ) \to ( 1 4 2 5 8 )
( 1 4 2 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
Artık dizi sıralıdır ancak algoritma işlemin bittiğini bilmemektedir. 
Algoritmanın dizinin sıralandığını anlaması için bütün dizinin üzerinden hiçbir değişiklik yapmadan tam bir geçiş yapması gerekir.
Üçüncü Geçiş:
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
Sonuç olarak dizi sıralanmıştır ve algoritma sonlanır.

Kabarcık sıralama algoritması java kodları

public static void KabarcikSiralama(int[] dizi) {
  int temp;   // Yer değiştirmede kullanılacak geçici değişken
  
  for (int i = 1; i < dizi.length; i++) {
   for (int j = 0; j < dizi.length - i; j++) {
    
    //Önce gelen elaman bir sonrakinden büyükse ikisi yer değiştiriyor
    if (dizi[j] > dizi[j + 1]) {
     temp = dizi[j];
     dizi[j] = dizi[j + 1];
     dizi[j + 1] = temp;
    }
    
   }
  }
  
 }
  

Kodlara ulaşmak için github adresine gidin