Sıralama Algoritmaları

Kaynak
• Algoritma Geliştirme ve Veri Yapıları, Toros Rifat ÇÖLKESEN,
Papatya Yayıncılık, 3. Basım
• Uygulama Yazılımı: Dev-C++
(https://sourceforge.net/projects/orwelldevcpp/)
Sıralama
• Sıralama bilgilerin/verilerin belirli bir anahtar sözcüğe göre belirli bir
anlamda sıralı duruma getirilmesidir. Örneğin sayıları küçükten büyüğe
veya büyükten küçüğe sıralama, sözcükleri alfabetik sıraya göre sıralama
vb.
• Sıralama işleminde bir anahtar sözcük kullanılır ve bu sözcük sıralamada
ana unsurdur. Anahtar sözcük verinin bir kısmı 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.
• Birçok farklı sıralama algoritması vardır. Aşağıda en yaygın olarak bilinen
sıralama algortimaları verilmiştir.

1. Bubble Sort (Kabarcık Sıralama)

2. Quick Sort (Hızlı Sıralama)
3. Merge Sort (Birleşimli Sıralama)
4. Selection Sort (Seçmeli Sıralama)
5. İnsertion Sort (Araya Ekleme Esaslı Sıralama)
İnsertion Sort (Araya Ekleme Esaslı Sıralama)
• Bu algoritmada, sıralanacak dizinin ilk elemanı yerinde bırakılarak daha sonraki elemanlar tek tek ele alınır ve
dizideki uygun yere konulur. Sıralama sürecinde dizi iki parça gibi düşünülür: sıralanmış olan ön taraf ve henüz
sıralanmamış diğer kısım gibi. Sıralama yapılırken araya eklenecek elemanın yerini bulma ve geride kalanları birer
kaydırma işlemi gerekir.
• Bu algoritmada bir eleman eklemenin zaman karmaşıklığı 𝑂(𝑛) olurken sırasız bir diziyi tamamen sıralamak için
zaman karmaşıklığı 𝑂 𝑛2 dir.

void arayaEkleme(int D[], int N){

int i, k, ekle;
for(i=1;i<N;i++){
ekle=D[i];
for(k=i-1;k>=0 && ekle<=D[k];k--)
D[k+1]=D[k];
D[k+1]=ekle;

}
}

Resim kaynak: Problem Solving with Algorithms and

Data Structures, Brad Miller, David Ranum
 Araya Ekleme Esaslı Sıralama(Örnek Kod)
#include <iostream>
using namespace std;

void arayaEkleme(int D[], int N);

int main()
{
int B[]={13,12,15,1,9,24,50,1,8,12}; int k;
cout<<"Siralanmamis dizi : "<<endl<<endl;
for(k=0;k<10;k++)
printf("%d \t",B[k]);
cout<<endl<<endl<<"Araya Ekleme Siralama ile Siralaniyor : ..."<<endl<<endl;
arayaEkleme(B,10);
cout<<"Siralanmis dizi : "<<endl<<endl;
for(k=0;k<10;k++)
printf("%d \t",B[k]);cout<<endl<<endl;
system("pause");
return 0;
} //Devami diğer sayfada
 Araya Ekleme Esaslı Sıralama(Örnek Kod)

void arayaEkleme(int D[], int N){

int i, k, ekle;
for(i=1;i<N;i++)
{ ekle=D[i];
for(k=i-1;k>=0 && ekle<=D[k];k--)
D[k+1]=D[k];
D[k+1]=ekle;

}
}
Selection Sort (Seçmeli Sıralama)
• Seçmeli algoritmada dizinin bir ucundan (örn başından) başlanır. İ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; daha sonra ikinci eleman alınır ve kendisi dahil kalan elemanlar arasında ikinci küçük
eleman aranır ve ikinci elemanla yer değiştirilir. Bu işlem dizinin son elemanına kadar devam eder ve dizi sıralanmış olur.
• Seçmeli sıralama algoritmasının karmaşıklığı 𝑂 𝑛2 dir.
• Aşağıda örnek bir sıralama verilmiştir.

void secmeliSiralama(int D[], int N){

int i, index, j, enkucuk;
Resim kaynak: Data Structures Using c for(i=0;i<(N-1);i++)
Reema Thareja
{ enkucuk=D[N-1];index=N-1;
for(j=i;j<(N-1);j++)
if(D[j]<enkucuk)
{ enkucuk=D[j];index=j;}
D[index]=D[i];
D[i]=enkucuk;
}
}
 Seçmeli Sıralama(Örnek Kod)
#include <iostream>
using namespace std;
void secmeliSiralama(int D[], int N);
int main()
{
int B[]={13,12,15,1,9,24,50,1,8,12};int k;
cout<<"Siralanmamis dizi : "<<endl<<endl;
for(k=0;k<10;k++)
printf("%d \t",B[k]);
cout<<endl<<endl<<"Secmeli Siralama ile Siralaniyor : ..."<<endl<<endl;
secmeliSiralama(B,10);
cout<<"Siralanmis dizi : "<<endl<<endl;
for(k=0;k<10;k++)
printf("%d \t",B[k]);
cout<<endl<<endl;
system("pause");
return 0;
}// Devami diğer sayfada
 Seçmeli Sıralama(Örnek Kod)
void secmeliSiralama(int D[], int N){
int i, index, j, enkucuk;
for(i=0;i<(N-1);i++)
{ enkucuk=D[N-1];index=N-1;
for(j=i;j<(N-1);j++)
if(D[j]<enkucuk)
{
enkucuk=D[j];index=j;
}
D[index]=D[i];
D[i]=enkucuk;

}
}
Kabarcık Sıralama (Bubble Sort)
• Sıralanacak elemanlar üzerinde bir yönden diğer yöne doğru
ilerlerken komşu iki elemanın sıraya girecek şekilde
yerdeğiştirmesi esasına dayanır. Yer değiştirme işleminde
komşu iki eleman karşılaştırılır ve uygun yerlerde değillerse
yerleri değiştirilir.
• Bu işlemler sıralama bitene kadar devam eder. Elemanlar
üzerindeki bir tur dolaşma bir elemanın gerçek yerine
oturmasını sağlar. Dolayısıyla işleme yerine oturmayan
elemanlardan devam edilir.
• Kabarcık sıralamada iki çevrim kullanılır. Her çevrimde bir
eleman sıralı duruma geldiği için ikinci çevrim her seferinde bir
eksik yapılır. Bu davranış deniz kıyısına vuran dalgaların
hareketine benzetildiği için Kabarcık Sıralama Algoritması
denilmiştir.
Kabarcık Sıralama (Bubble Sort)
• Aşağıda örnek bir dizi üzerinde kabarcık sıralama algoritması
verilmiştir. Her bir sütünda dizinin i ile belirtilen iterasyon
sonucundaki hali verilmiştir. Oklar ise yer değiştirmeyi
göstermektedir.
• Kabarcık sıralama algoritmasının algoritma karmaşıklığı 𝑂 𝑛2 dir.

void 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])
{gecici=D[k];D[k]=D[k+1];D[k+1]=gecici;}
}
}
}
 Kabarcık Sıralama (Örnek Kod)
#include <iostream>
using namespace std;
void kabarcik(int D[], int N);
int main()
{
int B[]={13,12,15,1,9,24,50,1,8,12};int k;
cout<<"Siralanmamis dizi : "<<endl<<endl;
for(k=0;k<10;k++) printf("%d \t",B[k]);
cout<<endl<<endl<<"Kabarcik Siralama ile Siralaniyor : ..."<<endl<<endl;
kabarcik(B,10);
cout<<"Siralanmis dizi : "<<endl<<endl;
for(k=0;k<10;k++) printf("%d \t",B[k]);
cout<<endl<<endl;
system("pause");return 0;
} // Devami diger sayfada
 Kabarcık Sıralama (Örnek Kod)
void 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])
{
gecici=D[k];
D[k]=D[k+1];
D[k+1]=gecici;
}
}
}
}
Algoritma Karmaşıklığı
• Aşağıda şimdiye kadar bahsedilen özyinelemeli yapıya sahip
olmayan algoritmaların algoritma karmaşıklıkları tablo halinde
verilmiştir.
• Tabloya bakıldığında ortalama durum ve en kötü durum için
her üç algoritmanın da karmaşıklığı 𝑂 𝑛2 iken en iyi durum
için insertion sort diğerlerinden daha iyi performans
göstermektedir.

Kaynak: Data Structures and Algorithm

Analysis, Clifford A. Shaffer
Hızlı Sıralama (Quick Sort)
• Hızlı sıralama algortiması böl ve yönet politikası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ı gerçekleştirilir.
• Hızlı sıralama algoritmasına üç tane parametre gelmektedir. Biri dizi,
diğer ikisi de dizinin sıraya koyulacak parçasının sol ve sağ
taraflarının indis değerleridir. Algoritma ilk çağrıldığında, n elemanlı
dizi için sol=0, sağ=n-1 olur. Özyinelemeli çağırmalar sırasında sol
değer büyürken sağ değer küçülecektir. Ne zamanki sol değer sağ
değerden büyük olursa dizide bölünecek eleman kalmadığı anlaşılır
ve özyinelemeli çağırmaların geri dönüşü başlar. İlk çağrılan
özyinelemeli çağrının da dönüşü yapıldığında dizi sıralanmış olur.
• Hızlı sıralama algoritmasının ortalama durumda zaman karmaşıklığı
𝑂 𝑛𝑙𝑜𝑔𝑛 , en kötü durumdaki zaman karmaşıklığı 𝑂 𝑛2 dir.
Hızlı Sıralama (Quick Sort)
• Aşağıda hızlı sıralama algoritmasının bir örnek uygulaması
verilmiştir.

Kaynak: Data Structures and Algorithm

Analysis, Clifford A. Shaffer
 Hızlı Sıralama (Örnek Kod)
#include <iostream>
using namespace std;
void hizlisirala(int D[], int sol,int sag);
int main()
{
int B[]={13,12,15,1,9,24,50,1,8,12};
int k;
cout<<"Siralanmamis dizi : "<<endl<<endl;
for(k=0;k<10;k++) printf("%d \t",B[k]);
cout<<endl<<endl<<"Hizli Siralama ile Siralaniyor : ..."<<endl<<endl;
hizlisirala(B, 0,9);
cout<<"Siralanmis dizi : "<<endl<<endl;
for(k=0;k<10;k++) printf("%d \t",B[k]);
cout<<endl<<endl;
system("pause");
return 0;
} // Devami diger sayfada
 Hızlı Sıralama (Örnek Kod)
void hizlisirala(int D[], int sol,int sag)
{
int gecici, k, j, ortadaki;
k=sol;j=sag;
ortadaki=D[(sol+sag)/2];
do
{
while(D[k]<ortadaki && k<sag)
k++;
while(ortadaki< D[j] && j>sol)
j--;
if (k<=j){ gecici=D[k];D[k]=D[j];D[j]=gecici;
k++;j--; }

}while(k<=j); // parçalama bitti

if(sol<j) hizlisirala(D,sol,j);
if(k<sag) hizlisirala(D,k,sag);
}
Birleşimli Sıralama (Merge Sort)
• Böl ve yönet yaklaşımına dayanır. Özyinelemeli tasarımı bu
nedenle daha uygundur. Sıralanması istenen dizi elemanları
önce iki alt kümeye ayrılır ve fonksiyon kendisini sol alt kümesi
için iki defa ve sağ alt küme için iki defa çağırır. Parçalama
işlemi alt kümelerdeki eleman sayısı bir olana kadar devam
eder. Bu aşamadan sonra özyinelemeli çağrıların geri dönüşü
başlar, geri dönüşlerde alt kümeler elemanları sıralı olacak
şekilde birleştirilirler.
• Birleşimli sıralama algoritmasının en kötü durum algoritma
karmaşıklığı 𝑂 𝑁𝑙𝑜𝑔𝑁 dir.
Birleşimli Sıralama (Merge Sort)
• Örnek uygulama gösterimleri:

Resim kaynak: Data Structures and Algorithms:

Annotated Reference with Examples

Resim kaynak: Data Structures and Algorithm Analysis in

C++, Mark Allen Weiss, Pearson
 Birleşimli Sıralama (Örnek Kod)
#include <iostream>
using namespace std;

void merge(int arr[], int l, int m, int r);void mergeSort(int arr[], int l, int r);
int main()
{ int B[]={13,12,15,1,9,24,50,1,8,12};
int diziboyutu = sizeof(B) / sizeof(B[0]);int k;
cout<<"Siralanmamis dizi : "<<endl<<endl;
for(k=0;k<10;k++)
printf("%d \t",B[k]);
cout<<endl<<endl<<"Birlesimli Siralama ile Siralaniyor : ..."<<endl<<endl;
mergeSort(B, 0, diziboyutu - 1);
cout<<"Siralanmis dizi : "<<endl<<endl;
for(k=0;k<10;k++)
printf("%d \t",B[k]);cout<<endl<<endl;
system("pause");return 0;
} // Devami diğer sayfada
 Birleşimli Sıralama (Örnek Kod)
void merge(int arr[], int l, int m, int r)
{ int i, j, k; int n1 = m - l + 1;int n2 = r - m;int L[n1], R[n2];
for (i = 0; i < n1; i++) L[i] = arr[l + i];
for (j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
i = 0;j = 0;k = l;
while (i < n1 && j < n2) {if (L[i] <= R[j]) {arr[k] = L[i];i++;}
else {arr[k] = R[j];j++;}
k++;}
while (i < n1) {arr[k] = L[i];i++;k++;}while (j < n2) {arr[k] = R[j];j++;k++;}
}
void mergeSort(int arr[], int l, int r)
{ if (l < r) { int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}