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