Peki nedir bu kuyruk? Wiki şöyle diyor

FIFO (First In Fist Out – İlk Giren İlk Çıkar) mantığına dayalı kuyruk yapısı ile ilgili yazdığım class:

public class kuyruk {
	// private değişkenler
	private int maxBoyut;
	private long[] kuyrukDizi;
	private int front;
	private int rear;
	private int elemanSayisi;

	// constructor
	// kuyruk degisken_ismi = new kuyruk (eleman_sayisi);
	public kuyruk (int boyut){
		maxBoyut = boyut;
		kuyrukDizi = new long [maxBoyut];
		front = 0;
	    rear = -1;
	    elemanSayisi = 0;
	}

	// metodlar

	// kuyruk boş mu?
	public boolean bosMu() {
		if (elemanSayisi == 0) return true;
		else return false;
	}

	// kuyruk dolu mu?
	public boolean doluMu() {
		if (elemanSayisi == maxBoyut) return true;
		else return false;
	}

	// kuyruğa eleman ekleme
	public void insert (long eklenecekEleman){
		if (rear == maxBoyut -1) rear = -1;
		rear++;
		kuyrukDizi [rear] = eklenecekEleman;
		elemanSayisi++;
	}

	// kuyruktan eleman çekme
	public long remove(){
		long cikarilacak = kuyrukDizi [front++];
		if (front == maxBoyut) front = 0;
		elemanSayisi--;
		return cikarilacak;
	}

	// kuyruğun sonundaki eleman
	public long kuyrukNerde() {
		return kuyrukDizi[front];
	}

	// kuyruğun boyutu
	public int kuyrukBoyutu() {
		return elemanSayisi;
	}
}

yukarıdaki gibidir.

Bu arada Java’da yazdığım kod sayısı 100 satırı geçti bunlarla birlikte :P “Hello World” un üstüne bayağı şey yapmışım demek ki :)

C/C++ Kodu :

void bubbleSort(int dizi[], int elemanSayisi)
{
     int temp;
     int i, j;

     for (i=1; i<elemanSayisi; i++)
     {
         for (j=0; j<elemanSayisi-i; j++)
         {
             if(dizi[j] > dizi[j+1])
             {
                        temp = dizi [j];
                        dizi [j] = dizi [j+1];
                        dizi [j+1] = temp;
             }
         }
     }
}

Java Kodu :

    public static void BubbleSort(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++)
            {
                if (dizi[j] > dizi [j+1])
                {
                    temp = dizi [j];
                    dizi [j] = dizi [j+1];
                    dizi [j+1] = temp;
                }//Önce gelen elaman bir sonrakinden büyükse ikisi yer değiştiriyor
            }// Dizinin ardışık elamanlarını karşılaştırmak için kullandığımız döngü
        }// Her karşılaştırmadan sonra yeniden kaldığımız yerden devam etmemizi sağlayan döngü
    }

* Selection Sort
* Bubble sort
* Insertion sort
* Shell sort
* Merge sort
* Heapsort
* Quicksort
* Bucket sort
* Radix sort
* Distribution sort
* Shuffle sort
…

Listeyi uzatmak mümkün. Sıralanacak veririn boyutu, yazılacak kod maliyeti, sistem kaynakları, kullanıcı tercihi vb. durumlara göre herhangi biri tercih edilebilir.
Bunlardan Selection Sort’u inceleyelim. Sayı dizisini kullaracak olursak, algoritma ilk adımda tüm diziyi dolaşacak, en küçük elemanı bulup ilk sıraya yazacak.
Sonra dizinin kalan kısmında aynı işi yeniden yapacak. Kalan kısmı tarayıp en küçük elamanı bulup, ikinci sıraya yazacak. Bu şekilde son elemana kadar gidip en küçükten büyüğe doğru dizimiz sıralanmış olacak.

Viki’de aşağıdaki animasyonu buldum, Selection Sort için hazırlanmış basit bi şey.

Fonksiyon için de C ve Java’da aşağıdaki kodları yazdım. Aynı işi yapan benzer şeyler de yazılabilir.

C/C++ kodu :

void selectionSort (int dizi[], int elemanSayisi)
{
     int i, j, enKucuk, temp;
     for (i=0; i<elemanSayisi-1; i++)
     {
         enKucuk = i;
         for (j=i+1; j<elemanSayisi; j++)
         {
             if (dizi[j] < dizi [enKucuk])
             enKucuk = j;
         }
         temp = dizi[i];
         dizi[i] = dizi[enKucuk];
         dizi[enKucuk] = temp;
     }
}

Java kodu :

    private static void selectionSort(int [] dizi,int n)
    {
        int temp;
        int enKucuk;
        for(int i=0; i<n-1; i++)
        {
            enKucuk=i;
            for(int j=i; j<n; j++)
            {
                if (dizi[j] < dizi[enKucuk]) enKucuk=j;
            }
            temp=dizi[i];
            dizi[i]=dizi[enKucuk];
            dizi[enKucuk]=temp;
        }
    }

Fonksiyon argüman olarak aldığı diziyi Selection Sort algoritması ile sıralıyor.

İç içe iki tane döngü kullanıldığı için algoritmanın karmaşıklığı O(n²) olur. Küçük boyutlu dizilerde fazla kod yazmaya gerek kalmadan kullanılabilecek bir algoritmadır.