Sorting Algorithms

Bubble Sort

➀ Compare 2 consecutive elements. Swap if 1st one is larger than 2nd one.
➁ At the end of each iteration, largest element in the list bubbles up to the top of the list.
➂ The next iteration excludes the last element (i.e., largest element) in the list.

Insertion Sort

➀ An element in the list is picked and compared with all other elements prior to it in reverse order.
➁ If the element is smaller than the compared element, later is shifted to the right. Or else the element is inserted next to the compared element.

Selection Sort

➀ The list is scanned for the smallest element.
➁ At the end of each iteration, this smallest element is swapped with the first element in the list.
➂ The next iteration excludes the first element (i.e., smallest element) in the list.

Merge Sort

➀ A list is divided into 2 equal halves. Each half goes for a recursion (calling same function).
➁ It is expected to have 2 sorted sublists at the end of recursion.
➂ Merge 2 sorted sublists to form a full sorted list.

Quick Sort

➀ A pivot element is chosen and checked for an appropriate position in the list such that smaller elements are left to it and larger elements are right to it.
➁ The left and right sublists do the same through recursion.

Counting Sort

➀ The list is scanned for the maximum element.
➁ Another list (count list) is created of size (max element + 1) with all 0s.
➂ The list is traversed and the count list is updated accordingly with an appropriate count.
➃ Based on counts, the list is sorted.

Radix Sort

➀ Find the max value in the list. Find out how many digits it has.
➁ Starting from units, then to tens and hundreds, etc., arrange the elements based on sorted numbers in that digit place.

Bucket Sort

➀ First a bucket list is created. Each bucket in the list can contain elements of a certain range.
➁ Elements are scattered in buckets.
➂ Each bucket is sorted (other sorting technique).
➃ Elements from all buckets are gathered.

Heap Sort

➀ Elements are kept in heap either in Min-Heap or Max-Heap.
➁ The root is swapped with the rightmost child node and, then removed from the heap.
➂ Then the heap is heapified and this process continues till the heap is empty.

Shell Sort

➀ It uses insertion sort mechanism. But instead of scanning elements one-by-one, it uses a sequence.
Example of a sequence: N/2, N/4, N/8 where N is size of the list.
➁ So after each iteration, elements at particular intervals (based on sequence) are sorted.

Time Complexity

Algorithm	Best case	Average case	Worst case
Bubble Sort	O(n)	O(n²)	O(n²)
Selection Sort	O(n²)	O(n²)	O(n²)
Insertion Sort	O(n)	O(n²)	O(n²)
Merge Sort	O(n*logn)	O(n*logn)	O(n*logn)
Quick Sort	O(n*logn)	O(n*logn)	O(n²)
Counting Sort	O(n+k)	O(n+k)	O(n+k)
Radix Sort	O(n+k)	O(n+k)	O(n+k)
Bucket Sort	O(n+k)	O(n)	O(n²)
Heap Sort	O(n*logn)	O(n*logn)	O(n*logn)
Shell Sort	O(n*logn)	O(n*logn)	O(n²)

Space Complexity

Algoritma	Uzay Karmaşıklığı
➀ Bubble Sort	O(1)
➁ Selection Sort	O(1)
➂ Insertion Sort	O(1)
➃ Merge Sort	O(n)
➄ Quick Sort	O(logn)
➅ Counting Sort	O(max)
➆ Radix Sort	O(max)
➇ Bucket Sort	O(n+k)
➈ Heap Sort	O(1)
➉ Shell Sort	O(1)

Sıralama Algoritmaları

Bubble Sort

➀ İki ardışık eleman karşılaştırılır. İlk eleman ikinci elemandan büyükse yer değiştirilir.
➁ Her yinelemenin sonunda, listedeki en büyük eleman listenin en sağına gider.
➂ Bir sonraki yineleme, listedeki son elemanı (örneğin, en büyük elemanı) hariç tutar.

Insertion Sort

➀ Listedeki bir eleman seçilir ve ters sırayla kendisinden önceki tüm elemanlarla karşılaştırılır.
➁ Eğer eleman karşılaştırılan elemandan küçükse, karşılaştırılan eleman sağa kaydırılır. Aksi takdirde eleman, karşılaştırılan elemanın yanına yerleştirilir.

Selection Sort

➀ Liste, en küçük elemanı bulmak için taranır.
➁ Her iterasyonun sonunda, bulunan en küçük eleman listenin ilk elemanıyla yer değiştirilir.
➂ Bir sonraki iterasyon, listedeki ilk elemanı (yani en küçük elemanı) hariç tutar.

Merge Sort

➀ Liste, iki eşit parçaya bölünür. Her bir parça, aynı fonksiyonu çağırarak bir özyinelemeye (recursion) girer.
➁ Özyineleme sonunda iki sıralı alt listeye sahip olması beklenir.
➂ İki sıralı alt liste birleştirilerek tam sıralı bir liste oluşturulur.

Quick Sort

➀ Bir pivot eleman seçilir ve listedeki uygun bir pozisyonda olup olmadığı kontrol edilir. Küçük elemanlar pivotun soluna, büyük elemanlar ise sağına yerleştirilir.
➁ Sol ve sağ alt listeler aynı işlemi özyineleme yoluyla yapar.

Counting Sort

➀ Liste, maksimum elemanı bulmak için taranır.
➁ Boyutu (maksimum eleman + 1) olan ve tüm elemanları 0 olan bir sayma listesi oluşturulur.
➂ Liste taranır ve sayma listesi uygun şekilde güncellenir.
➃ Sayımlara dayanarak liste sıralanır.

Radix Sort

➀ Listedeki maksimum değer bulunur. Kaç basamaklı olduğu tespit edilir.
➁ Birler basamağından başlayarak, onlar ve yüzler basamağı gibi, elemanlar ilgili basamaklardaki sıralı sayılara göre düzenlenir.

Bucket Sort

➀ İlk olarak bir kova listesi oluşturulur. Listedeki her kova, belirli bir aralıktaki elemanları içerebilir.
➁ Elemanlar kovalar arasında dağıtılır.
➂ Her kova ayrı ayrı sıralanır (başka bir sıralama tekniğiyle).
➃ Tüm kovaların elemanları toplanır.

Heap Sort

➀ Elemanlar, Min-Heap veya Max-Heap yapısında tutulur.
➁ Kök eleman, en sağdaki çocuk düğümle değiştirilir ve ardından heap'ten çıkarılır.
➂ Heap tekrar düzenlenir ve bu işlem heap boşalana kadar devam eder.

Shell Sort

➀ Insertion sort sıralama mekanizmasını kullanır. Ancak elemanları tek tek taramak yerine bir dizi kullanır.
Örneğin bir dizi: N/2, N/4, N/8, burada N listenin boyutudur.
➁ Her iterasyondan sonra, belirli aralıklardaki (diziye göre) elemanlar sıralanır.

Zaman Karmaşıklığı

Algoritma	En İyi Durum	Ortalama Durum	En Kötü Durum
Bubble Sort	O(n)	O(n²)	O(n²)
Selection Sort	O(n²)	O(n²)	O(n²)
Insertion Sort	O(n)	O(n²)	O(n²)
Merge Sort	O(n*logn)	O(n*logn)	O(n*logn)
Quick Sort	O(n*logn)	O(n*logn)	O(n²)
Counting Sort	O(n+k)	O(n+k)	O(n+k)
Radix Sort	O(n+k)	O(n+k)	O(n+k)
Bucket Sort	O(n+k)	O(n)	O(n²)
Heap Sort	O(n*logn)	O(n*logn)	O(n*logn)
Shell Sort	O(n*logn)	O(n*logn)	O(n²)

Alan Karmaşıklığı

Algoritma	Uzay Karmaşıklığı
➀ Bubble Sort	O(1)
➁ Selection Sort	O(1)
➂ Insertion Sort	O(1)
➃ Merge Sort	O(n)
➄ Quick Sort	O(logn)
➅ Counting Sort	O(max)
➆ Radix Sort	O(max)
➇ Bucket Sort	O(n+k)
➈ Heap Sort	O(1)
➉ Shell Sort	O(1)