Veri Yapıları ve Programlama

11 - Sıralama Algoritmaları

Emre Can Yılmaz
[email protected]

Ondokuz Mayıs Üniversitesi

2026

Sıralama Algoritmaları

Sıralama algoritması, bir dizinin veya listenin elemanlarını belirli bir ölçüte göre yeniden düzenlemek için kullanılır.

Örnekte sayılar küçükten büyüğe sıralanmıştır.

Neden Farklı Sıralama Algoritmaları Var?

Aynı işi yapan birçok sıralama algoritması vardır; ancak bu algoritmaların çalışma biçimleri ve maliyetleri farklıdır.

Bazı algoritmalar:

  • Anlaması ve kodlaması kolaydır.
  • Küçük dizilerde yeterince iyi çalışır.
  • Büyük veri üzerinde yavaş kalır.
  • Verinin mevcut sırasından olumlu etkilenebilir.
  • Ek bellek kullanarak daha dengeli çalışma süresi sağlayabilir.

Bu Sunumda İncelenecek Algoritmalar

  • Seçerek Sıralama (Selection Sort)
  • Baloncuk Sıralama (Bubble Sort)
  • Ekleme Sıralaması (Insertion Sort)
  • Hızlı Sıralama (Quick Sort)
  • Birleştirme Sıralaması (Merge Sort)

Sıralama Algoritmalarını Nasıl Karşılaştırırız?

Ölçüt Anlamı
Karşılaştırma sayısı Elemanların birbirleriyle kaç kez karşılaştırıldığı
Yer değiştirme sayısı Elemanların dizide kaç kez yer değiştirdiği
En iyi durum Algoritmanın en avantajlı girişteki çalışma maliyeti
Ortalama durum Genel kullanımda beklenen çalışma maliyeti
En kötü durum Algoritmanın en zor girişteki çalışma maliyeti
Ek bellek kullanımı Algoritmanın dizi dışında ne kadar ek alan kullandığı
Kararlılık Eşit değerli elemanların kendi aralarındaki sırayı koruyup korumadığı

Kararlı Sıralama Nedir?

Bir sıralama algoritması, eşit anahtara sahip elemanların başlangıçtaki göreli sırasını koruyorsa kararlı kabul edilir.

Örneğin öğrencileri nota göre sıraladığımızı düşünelim:

Ali   80
Ayşe  90
Veli  80

Nota göre küçükten büyüğe sıralama yapıldığında Ali ve Veli’nin ikisi de 80 aldığı için kendi aralarındaki sıra korunuyorsa algoritma kararlıdır.

Basit Sıralama Algoritmaları

İlk üç algoritma daha çok sıralama mantığını anlamak için kullanılır:

  • Seçerek Sıralama
  • Baloncuk Sıralama
  • Ekleme Sıralaması

Bu algoritmaların ortak özelliği, çoğu durumda O(n²) çalışma maliyetine sahip olmalarıdır.

Bu nedenle büyük diziler için genellikle tercih edilmezler; ancak algoritma mantığını öğrenmek için oldukça uygundurlar.

Seçerek Sıralama (Selection Sort)

Seçerek sıralama, her dış döngü turunda dizinin sıralanmamış bölümündeki en küçük elemanı bulur ve bu elemanı sıralanmamış bölümün başına taşır.

Temel fikir:

En küçük elemanı bul.
Onu mevcut konuma yerleştir.
Sonraki konuma geç.

Selection Sort: Çalışma Mantığı

Dizi iki bölüm gibi düşünülür:

[sıralı bölüm] [sıralanmamış bölüm]

Başlangıçta sıralı bölüm boştur.

Her dış döngü turunda:

  1. Sıralanmamış bölümdeki en küçük eleman bulunur.
  2. Bu eleman sıralanmamış bölümün ilk elemanıyla yer değiştirir.
  3. Sıralı bölüm bir eleman büyür.

Selection Sort: İlk Adım

İlk eleman geçici olarak en küçük eleman kabul edilir.

Selection Sort: En Küçüğü Arama

En küçük kabul edilen eleman, dizinin geri kalan elemanlarıyla karşılaştırılır.

Daha küçük bir eleman bulunursa, en küçük elemanın konumu güncellenir.

Selection Sort: Yer Değiştirme

Sıralanmamış bölümdeki en küçük eleman bulunduğunda, bu eleman sıralanmamış bölümün başındaki elemanla yer değiştirir.

Selection Sort: Sonraki Turlar

Her dış döngü turundan sonra dizinin başındaki sıralı bölüm bir eleman büyür.

Selection Sort: Devam Eden Süreç

Selection Sort: Sıralı Bölüm Büyür

Selection Sort: Son Durum

Selection Sort: Kritik C Kodu

for (int i = 0; i < n - 1; i++) {
    int minIndex = i;

    for (int j = i + 1; j < n; j++) {
        if (arr[j] < arr[minIndex]) {
            minIndex = j;
        }
    }

    int temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
}

Tam kod:

https://gist.github.com/ecylmz/68f7646b1805c623db1b553867ef8585#file-selection-sort-c

Selection Sort: Özellikler

Özellik Değer
En iyi durum O(n²)
Ortalama durum O(n²)
En kötü durum O(n²)
Ek bellek O(1)
Kararlı mı? Yer değiştirmeli temel sürüm genellikle kararlı değildir

Selection Sort’un avantajı basit olmasıdır.

Dezavantajı ise dizi zaten sıralı olsa bile çok sayıda karşılaştırma yapmasıdır.

Alıştırma Sorusu

35, 40, 25, 10, 45 dizisi Selection Sort ile küçükten büyüğe sıralanıyor.

Dizi kaçıncı dış döngü turunun sonunda tamamen sıralı hale gelir?

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5

Alıştırma Çözümü

Başlangıç:

35, 40, 25, 10, 45
  1. tur sonunda:
10, 40, 25, 35, 45
  1. tur sonunda:
10, 25, 40, 35, 45
  1. tur sonunda:
10, 25, 35, 40, 45

Doğru cevap: C) 3

Baloncuk Sıralama (Bubble Sort)

Baloncuk sıralama, komşu elemanları karşılaştırarak yanlış sırada olanları yer değiştirir.

Her dış döngü turunda büyük elemanlar dizinin sonuna doğru ilerler.

Bu nedenle algoritmanın adı “baloncuk” benzetmesiyle açıklanır: büyük elemanlar her turda sona doğru taşınır.

Bubble Sort: Temel Fikir

Artan sıralama için:

Yan yana duran iki elemanı karşılaştır.
Soldaki eleman sağdakinden büyükse yer değiştir.
Dizinin sonuna kadar devam et.

Her tur sonunda sıralanmamış bölümdeki en büyük eleman kendi yerine yerleşir.

Bubble Sort: İlk Tur

  1. Birinci ve ikinci eleman karşılaştırılır.
  2. Yanlış sıradaysa yer değiştirilir.
  3. Sonra ikinci ve üçüncü eleman karşılaştırılır.
  4. İşlem dizinin sonuna kadar devam eder.

Bubble Sort: Sonraki Turlar

Aynı işlem kalan elemanlar için tekrar edilir.

Her turdan sonra en büyük eleman sıralanmamış bölümün sonuna yerleşir.

Bubble Sort: Karşılaştırma Sınırı

Her turda dizinin tamamını tekrar kontrol etmek gerekmez.

Çünkü önceki turda en büyük eleman zaten sona yerleşmiştir.

Bubble Sort: Son Durum

Sıralanmamış tüm elemanlar doğru konumlarına yerleştiğinde dizi sıralanmış olur.

Bubble Sort: Kritik C Kodu

for (int i = 0; i < n - 1; i++) {
    for (int j = 0; j < n - i - 1; j++) {
        if (arr[j] > arr[j + 1]) {
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

Tam kod:

https://gist.github.com/ecylmz/68f7646b1805c623db1b553867ef8585#file-bubble-sort-c

Bubble Sort: Erken Durma İyileştirmesi

Dizi bir tur boyunca hiç değişmediyse zaten sıralıdır.

Bu durumda algoritma erken durdurulabilir.

for (int i = 0; i < n - 1; i++) {
    int swapped = 0;

    for (int j = 0; j < n - i - 1; j++) {
        if (arr[j] > arr[j + 1]) {
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
            swapped = 1;
        }
    }

    if (!swapped) {
        break;
    }
}

Bubble Sort: Özellikler

Özellik Değer
En iyi durum Erken durma varsa O(n), yoksa O(n²)
Ortalama durum O(n²)
En kötü durum O(n²)
Ek bellek O(1)
Kararlı mı? Evet

Bubble Sort anlaşılması kolaydır; ancak büyük diziler için verimli değildir.

Ekleme Sıralaması (Insertion Sort)

Ekleme sıralaması, sıralanmamış bir elemanı her turda alıp sıralı bölümdeki uygun konuma yerleştirir.

Kartları elde sıralama örneğine benzer:

  • Eldeki kartlar sıralı kabul edilir.
  • Yeni kart alınır.
  • Uygun konuma yerleştirilir.

Insertion Sort: Temel Fikir

Dizi iki bölüm gibi düşünülür:

[sıralı bölüm] [sıralanmamış bölüm]

Başlangıçta ilk eleman tek başına sıralı kabul edilir.

Her turda sıralanmamış bölümden bir eleman alınır ve soldaki sıralı bölümde doğru yere yerleştirilir.

Burada bir tur, sıralanmamış bölümden bir elemanın alınıp sıralı bölüme yerleştirilmesi anlamına gelir.

Insertion Sort: Başlangıç

Aşağıdaki diziyi sıralamamız gerektiğini düşünelim.

Insertion Sort: İkinci Elemanı Yerleştirme

İkinci eleman alınır ve geçici olarak key değişkeninde saklanır.

key, solundaki sıralı bölümde uygun konuma yerleştirilir.

Insertion Sort: Sıralı Bölüm Genişler

İlk iki eleman artık sıralı kabul edilir.

Üçüncü eleman alınır ve solundaki elemanlarla karşılaştırılarak uygun konuma yerleştirilir.

Insertion Sort: Devam Eden Süreç

Her turda bir eleman sıralı bölüme eklenir.

Insertion Sort: Son Durum

Insertion Sort: Kritik C Kodu

for (int i = 1; i < n; i++) {
    int key = arr[i];
    int j = i - 1;

    while (j >= 0 && arr[j] > key) {
        arr[j + 1] = arr[j];
        j--;
    }

    arr[j + 1] = key;
}

Tam kod:

https://gist.github.com/ecylmz/68f7646b1805c623db1b553867ef8585#file-insertion-sort-c

Insertion Sort: Özellikler

Özellik Değer
En iyi durum O(n)
Ortalama durum O(n²)
En kötü durum O(n²)
Ek bellek O(1)
Kararlı mı? Evet

Insertion Sort özellikle küçük dizilerde ve neredeyse sıralı verilerde iyi sonuç verebilir.

Basit Algoritmaları Karşılaştıralım

Algoritma Temel fikir En iyi Ortalama En kötü Kararlı mı?
Selection Sort En küçüğü seç O(n²) O(n²) O(n²) Genelde hayır
Bubble Sort Komşuları değiştir O(n)* O(n²) O(n²) Evet
Insertion Sort Uygun yere ekle O(n) O(n²) O(n²) Evet

* Bubble Sort için O(n) en iyi durum, erken durma kontrolü kullanılan sürüm için geçerlidir.

Böl ve Yönet Yaklaşımı

Bazı algoritmalar problemi daha küçük parçalara ayırarak çözer.

Genel yapı:

  1. Problemi alt parçalara böl.
  2. Alt problemleri çöz.
  3. Sonuçları uygun şekilde birleştir veya yerleştir.

Quick Sort ve Merge Sort bu yaklaşıma dayanır; ancak bölme ve sonuç üretme biçimleri farklıdır.

Quick Sort ve Merge Sort Farkı

Algoritma Bölme biçimi Sonuç üretme biçimi
Quick Sort Pivot seçerek küçük ve büyükleri ayırır Pivot doğru konuma yerleşir; alt diziler ayrıca sıralanır
Merge Sort Diziyi ortadan ikiye böler Sıralı alt dizileri birleştirir

Quick Sort’ta asıl iş bölme sırasında yapılır.

Merge Sort’ta asıl iş birleştirme sırasında yapılır.

Hızlı Sıralama (Quick Sort)

Quick Sort, bir pivot eleman seçerek diziyi iki bölüme ayırır:

[pivottan küçük/eşit elemanlar] pivot [pivottan büyük elemanlar]

Daha sonra aynı işlem sol ve sağ alt diziler için tekrarlanır.

Quick Sort: Pivot Seçimi

Pivot farklı şekillerde seçilebilir:

  • İlk eleman
  • Son eleman
  • Ortadaki eleman
  • Rastgele bir eleman

Bu sunumda pivot olarak dizinin en sağındaki eleman seçilecektir.

Quick Sort: Partition İşlemi

Partition işlemi, diziyi pivot etrafında yeniden düzenler.

Amaç:

Pivotun solunda küçük/eşit elemanlar,
pivotun sağında büyük elemanlar kalsın.

Quick Sort: İndekslerin Rolü

Bu sunumda, pivotun en sağdaki eleman seçildiği yaygın partition yaklaşımı kullanılacaktır.

İki önemli indeks vardır:

İndeks Görevi
j Diziyi soldan sağa tarar
i Pivottan küçük/eşit elemanların bittiği sınırı gösterir

arr[j] <= pivot olduğunda i bir artırılır ve arr[i] ile arr[j] yer değiştirir.

Quick Sort: İlk Karşılaştırmalar

Pivot sabit tutulur.

Dizi soldan sağa taranır ve elemanlar pivot ile karşılaştırılır.

Quick Sort: Büyük Elemanla Karşılaşma

Pivot değerinden büyük bir eleman bulunduğunda bu eleman şimdilik yerinde kalır.

Amaç, daha sonra bulunacak küçük bir elemanla yer değiştirebilmektir.

Quick Sort: Küçük Elemanı Öne Alma

Pivot değerinden küçük veya eşit bir eleman bulunduğunda bu eleman sol bölüme alınır.

Quick Sort: Bölme Devam Eder

Tarama işlemi pivotun bir önceki elemanına kadar devam eder.

Quick Sort: Pivotun Yerleştirilmesi

Tarama bitince pivot, küçük/eşit elemanların hemen sağına yerleştirilir.

Böylece pivot kendi doğru konumuna geçmiş olur.

Quick Sort: Alt Diziler

Pivot doğru konuma yerleştirildikten sonra aynı işlem sol ve sağ alt diziler için tekrarlanır.

Alt diziler tek elemanlı veya boş hale geldiğinde işlem durur.

Quick Sort: Partition Kodu

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;

    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;

            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }

    int temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;

    return i + 1;
}

Quick Sort: Özyinelemeli Yapı

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pivotIndex = partition(arr, low, high);

        quickSort(arr, low, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, high);
    }
}

Tam kod:

https://gist.github.com/ecylmz/68f7646b1805c623db1b553867ef8585#file-quick-sort-c

Quick Sort: Özellikler

Özellik Değer
En iyi durum O(n log n)
Ortalama durum O(n log n)
En kötü durum O(n²)
Ek bellek Ortalama O(log n), en kötü O(n)
Kararlı mı? Genelde hayır

Quick Sort çoğu pratik durumda hızlıdır; ancak kötü pivot seçimleri performansı düşürebilir.

Birleştirme Sıralaması (Merge Sort)

Merge Sort da böl ve yönet yaklaşımını kullanır.

Temel fikir:

  1. Diziyi ikiye böl.
  2. Alt dizileri ayrı ayrı sırala.
  3. Sıralı alt dizileri birleştir.

Merge Sort’ta bölme işlemi kolaydır; asıl iş sıralı birleştirme aşamasındadır.

Merge Sort: Genel Yapı

Dizi sürekli ikiye bölünür.

Bölme işlemi, her parça tek elemanlı hale gelene kadar devam eder.

Tek elemanlı diziler zaten sıralı kabul edilir.

Merge Sort: Örnek Dizi

Sıralanmak istenen dizi:

5, 7, 2, 9, 6, 1, 3, 7

Önce bölme adımları uygulanır.

Sonra küçük sıralı parçalar birleştirilerek daha büyük sıralı parçalar oluşturulur.

Merge Sort: Bölme Şeması

5 7 2 9 6 1 3 7
      /       \
 5 7 2 9     6 1 3 7
   /  \       /  \
 5 7  2 9   6 1  3 7
 / \  / \   / \  / \
5   7 2  9 6   1 3   7

Bu noktada parçalar tek elemanlı hale gelmiştir.

Tek elemanlı parçalar sıralı kabul edilir.

Merge Sort: Birleştirme Şeması

5   7   2   9   6   1   3   7
 \ /     \ /     \ /     \ /
5 7     2 9     1 6     3 7
   \     /         \     /
  2 5 7 9         1 3 6 7
        \         /
   1 2 3 5 6 7 7 9

Birleştirme sırasında her adımda küçük eleman önce alınır.

Merge Sort: Birleştirme Mantığı

İki sıralı dizi düşünelim:

Sol:  2, 5, 7, 9
Sağ:  1, 3, 6, 7

Her adımda iki dizinin başındaki elemanlar karşılaştırılır.

Küçük olan eleman sonuç dizisine eklenir.

Bu işlem iki alt dizi tamamen bitene kadar devam eder.

Merge Sort: Merge İşlemi

while (i < leftSize && j < rightSize) {
    if (left[i] <= right[j]) {
        arr[k] = left[i];
        i++;
    } else {
        arr[k] = right[j];
        j++;
    }

    k++;
}

left[i] <= right[j] kullanımı, eşit elemanlarda soldaki elemanı önce aldığı için kararlılığı korur.

Merge Sort: Kalan Elemanlar

Bir alt dizi erken biterse diğer alt dizide kalan elemanlar sonuç dizisine eklenir.

while (i < leftSize) {
    arr[k] = left[i];
    i++;
    k++;
}

while (j < rightSize) {
    arr[k] = right[j];
    j++;
    k++;
}

Tam kod:

https://gist.github.com/ecylmz/68f7646b1805c623db1b553867ef8585#file-merge-sort-c

Merge Sort: Özellikler

Özellik Değer
En iyi durum O(n log n)
Ortalama durum O(n log n)
En kötü durum O(n log n)
Ek bellek O(n)
Kararlı mı? Evet

Merge Sort’un çalışma süresi dengelidir; ancak ek dizi kullandığı için bellek maliyeti Quick Sort’a göre daha yüksektir.

Tüm Algoritmaları Karşılaştıralım

Algoritma En iyi Ortalama En kötü Ek bellek Kararlı mı?
Selection Sort O(n²) O(n²) O(n²) O(1) Genelde hayır
Bubble Sort O(n)* O(n²) O(n²) O(1) Evet
Insertion Sort O(n) O(n²) O(n²) O(1) Evet
Quick Sort O(n log n) O(n log n) O(n²) Ort. O(log n), kötü O(n) Genelde hayır
Merge Sort O(n log n) O(n log n) O(n log n) O(n) Evet

* Bubble Sort için O(n) en iyi durum, erken durma kontrolü kullanılan sürüm için geçerlidir.

Hangi Algoritma Ne Zaman Düşünülebilir?

Durum Uygun Yaklaşım
Algoritma mantığını yeni öğreniyorsak Selection, Bubble, Insertion
Dizi küçükse Insertion Sort yeterli olabilir
Dizi neredeyse sıralıysa Insertion Sort veya erken durmalı Bubble Sort
Genel kullanımda hızlı bir algoritma istiyorsak Quick Sort
En kötü durumda da dengeli süre istiyorsak Merge Sort
Kararlı sıralama gerekiyorsa Insertion Sort, Bubble Sort, Merge Sort
Ek bellek az kullanılmalıysa Selection, Bubble, Insertion; çoğu pratik durumda Quick Sort

Kısa Alıştırmalar

  1. Aşağıdaki dizide Selection Sort’un ilk dış döngü turu sonunda dizi nasıl olur?
8, 3, 6, 2, 5
  1. Aşağıdaki dizi Bubble Sort’un ilk turundan sonra nasıl görünür?
4, 1, 3, 2
  1. Aşağıdaki dizide Insertion Sort ikinci tur sonunda nasıl bir sıralı bölüm oluşturur?
7, 2, 5, 1

Kısa Alıştırmaların Cevapları

  1. Selection Sort:
2, 3, 6, 8, 5
  1. Bubble Sort:
1, 3, 2, 4
  1. Insertion Sort ikinci tur sonunda:
2, 5, 7, 1

İlk üç eleman sıralı bölüm haline gelmiştir.

Genel Özet

  • Selection Sort her turda en küçük elemanı seçer.
  • Bubble Sort komşu elemanları karşılaştırır.
  • Insertion Sort elemanı sıralı bölümde uygun konuma ekler.
  • Quick Sort pivot seçerek diziyi ikiye ayırır.
  • Merge Sort diziyi ikiye böler ve sıralı parçaları birleştirir.
  • Küçük dizilerde basit algoritmalar yeterli olabilir.
  • Büyük dizilerde genellikle ortalama veya en kötü durumda O(n log n) davranış gösteren algoritmalar tercih edilir.
  • Algoritma seçerken çalışma süresi, bellek kullanımı ve kararlılık birlikte değerlendirilmelidir.