Nama : ANDINI PRATIWI

NIM : 161402088
KOM A2

10 MACAM ALGORITMA SORTING (SELAIN YANG SUDAH DIPELAJARI)

1. Exchange sort
2. Comb sort
3. Heap sort
4. Shell sort
5. Cocktail sort
6. Radix sort
7. Pigeonhole sort
8. Bucket sort
9. Counting sort
10. Tim sort

1. EXCHANGE SORT
Exchange sort sangat mirip dengan Bubble Sort. Banyak yang mengatakan Bubble Sort sama dengan
Exchange Sort. Pebedaannya adalah dalam hal bagaimana membandingkan antar elemen-elemennya.

Exchange sort membandingkan suatu elemen dengan elemen-elemen lainnya dalam array
tersebut, dan melakukan pertukaran elemen jika perlu. Jadi ada elemen yang selalu menjadi
elemen pusat (pivot).
Sedangkan Bubble sort akan membandingkan elemen pertama/terakhir dengan elemen
sebelumnya/sesudahnya, kemudian elemen tersebut itu akan menjadi pusat (pivot) untuk
dibandingkan dengan elemen sebelumnya/sesudahnya lagi, begitu seterusnya.

Konsep dasar exchange sorting adalah membandingkan tempat dari masing-masing nomor dan
menukarkannya. Contohnya, ada deretan angka yang akan diurut yaitu 13, 25, 2, atau 3, exchange
sorting akan melakukan tindakan berikut:

pg. 1
Kompleksitas waktu dari exchange sorting ditentukan oleh jumlah input N. Biasanya dilambangkan
dengan O (N2). Waktu yang tepat dibutuhkan ditunjukkan di bawah ini.

Pseudocode dari exchange sort adalah:

void exchangeSrot (int n, keytype s [])
{
index i, j;
for (i = 1; i <= n-1; i ++)
for (j = i + 1; j <= n; j ++)
if (s [j] <s [i])
exchange s [i] and s [j]
}
// where n is the size of the array and s [] is the array.

2. COMB SORT
Comb sort adalah algoritma penyortiran berbasis perbandingan dan pertukaran serta perpanjangan
ke algoritma bubble sort. Pada comb sort, gap diperkenalkan, gap awal sangat besar dan setelah setiap
iterasi gap berkurang sampai menjadi 1. Perhitungan gap bergantung pada faktor shrink. Faktor shrink
yang ideal adalah 1,3. Mari kita ambil contoh dan lakukan comb sort pada list[] = {5, 7, 4, 8, 2, 6}
dengan faktor shrink = 1.3. Di sini adalah representasi bergambar algoritma comb sort. Pada iterasi
pertama dengan faktor shrink 1.24, gap akan menjadi 6 / 1.24 = 4, dimana 6 adalah jumlah elemen.

Pada iterasi pertama 5 dibandingkan dengan elemen berjauhan 2, karena 5 lebih besar dari 2, maka
mereka dipertukarkan. 7 dibandingkan dengan elemen berjauhan 6, karena 7 lebih besar dari 6, jadi
mereka dipertukarkan. Jika unsur-unsurnya sudah dalam urutan diurutkan maka tidak perlu ditukar.
Perulangan selanjutnya cukup jelas dengan gambar di bawah ini.

pg. 2
 Struktur data Array

Worst case performance

Best case performance

Average case performance

, dimana p adalah angka dari inkremen

Worst case space complexity

Pseudocode comb sort:

function combsort(array input)

gap := input.size // Initialize gap size

shrink := 1.3 // Set the gap shrink factor
sorted := false

loop while sorted = false

// Update the gap value for a next comb
gap := floor(gap / shrink)
if gap > 1
sorted := false // We are never sorted as long as gap >
1
else
gap := 1
sorted := true // If there are no swaps this pass, we
are done
end if

// A single "comb" over the input list

i := 0
loop while i + gap < input.size // See Shell sort for a
similar idea
if input[i] > input[i+gap]
swap(input[i], input[i+gap])
sorted := false
// If this assignment never happens within the loop,

pg. 3
 // then there have been no swaps and the list is
sorted.
end if

i := i + 1
end loop

end loop
end function

3. HEAP SORT
Algoritma Heap Sort adalah salah satu algoritma penyortiran yang paling sulit untuk dipahami. Dengan
kata lain, algoritma ini berasal dari banyak modifikasi dari algoritma selection sort. Heap adalah
struktur data berbasis pohon khusus. Semua simpul Heap harus memenuhi kondisi berikut.

Shape Property
Struktur data Heap harus selalu berupa pohon biner yang lengkap. Yang berarti masing-masing harus
memiliki dua anak.

Heap Property
- Semua simpul adalah lebih besar dari atau sama dengan atau kurang dari atau sama dengan masing-
masing anak.
- Jika simpul induk lebih besar dari pada anak-anak mereka, Heap disebut Max-Heap, dan jika simpul
induknya lebih kecil dari simpul anak-anak mereka, Heap disebut Min-Heap.

Cara kerja dari heap sort seperti berikut:

Buat suatu heap
Ambil isi dari root, lalu masukkan kedalam sebuah array.
Hapus element root dengan mempertahankan properti heap.
Ulangi sampai tree menjadi kosong

Heapsort seperti selection sort, tapi dengan cara yang lebih baik untuk mendapatkan elemen terbesar.
Alih-alih memindai semua item untuk menemukan yang maksimal, ia menariknya dari tumpukan.
Tumpukan memiliki sifat yang memungkinkan heapsort untuk bekerja di tempat, tanpa memori
tambahan.

Create heap adalah O (N lg N). Popping item adalah O (1), dan memperbaiki tumpukan setelah pop
adalah lgN. Ada N pop, jadi ada O (N lg N) faktor lain, yaitu O (N lg N) secara keseluruhan. Heapsort
memiliki perilaku O (N lgN), bahkan dalam kasus terburuk, membuatnya bagus untuk aplikasi real-
time.

pg. 4
Pseudocode heap sort:
Heapsort(A as array)
BuildHeap(A)
for i = n to 1
swap(A[1], A[i])
n = n - 1
Heapify(A, 1)

BuildHeap(A as array)
n = elements_in(A)
for i = floor(n/2) to 1
Heapify(A,i,n)

Heapify(A as array, i as int, n as int)

left = 2i
right = 2i+1

if (left <= n) and (A[left] > A[i])

max = left
else
max = i

if (right<=n) and (A[right] > A[max])

max = right

if (max != i)
swap(A[i], A[max])
Heapify(A, max)

Berikut adalah gambar cara kerja heap sort:

pg. 5
pg. 6
4. SHELL SORT
Dikembangkan pertama oleh Donald Shell. Secara teknis merupakan cara yang dimodifikasi dan efisien
dalam menerapkan insertion sort. Algoritma Shell Sort adalah algoritma yang tidak stabil. Hanya saja,
alih-alih membandingkan setiap elemen dengan setiap elemen lainnya, kami mengambil celah yang
ditentukan dan kemudian membandingkan kedua elemen tersebut. Dalam algoritma ini kita mulai
dengan gap terbesar dan kemudian menurunkan gap saat kita melanjutkan. Ini adalah algoritma
sortasi yang sangat cepat.

Pseudocode shell sort:

procedure shellSort()
A : array of items
/* calculate interval*/
while interval < A.length /3 do:
interval = interval * 3 + 1
end while

while interval > 0 do:

for outer = interval; outer < A.length; outer ++ do:

/* select value to be inserted */

valueToInsert = A[outer]
inner = outer;

/*shift element towards right*/

while inner > interval -1 && A[inner - interval] >=
valueToInsert do:
A[inner] = A[inner - interval]
inner = inner - interval
end while

/* insert the number at hole position */

A[inner] = valueToInsert
end for

/* calculate interval*/

pg. 7
 interval = (interval -1) /3;
end while
end procedure

Berikut adalah contoh gambar cara kerja shell sort:

5. COCKTAIL SORT
Cocktail Sort adalah variasi dari Bubble sort. Algoritma Bubble sort selalu melintasi elemen dari kiri
dan memindahkan elemen terbesar ke posisi yang benar pada iterasi pertama dan kedua terbesar
pada iterasi kedua dan seterusnya. Cocktail Sort melintasi melalui array yang diberikan di dua arah
sebagai alternatif.

Algoritma: Setiap iterasi algoritma dipecah menjadi 2 tahap:

pg. 8
Tahap pertama loop melalui array dari kiri ke kanan, seperti Bubble Sort. Selama loop, item yang
berdekatan dibandingkan dan jika nilai di sebelah kiri lebih besar dari nilai di sebelah kanan, maka
nilai ditukar. Pada akhir iterasi pertama, jumlah terbesar akan berada di akhir array.
Tahap kedua berputar melalui array dalam arah yang berlawanan - mulai dari item sebelum item
yang terakhir dipilah, dan kembali ke awal array. Di sini juga, item yang berdekatan dibandingkan
dan ditukar jika diperlukan.

Berikut adalah contoh gambar cara kerja cocktail sort:

Pseudocode cocktail sort:

function cocktailSort( A : list of sortable items )
do
swapped := false
for each i in 0 to length( A ) - 2 do
if A[ i ] > A[ i+1 ] then // test whether the two
// elements are in the wrong
// order
swap( A[ i ], A[ i+1 ] ) // let the two elements
// change places
swapped := true;
if swapped = false then
// we can exit the outer loop here if no swaps occurred.
break do-while loop;
swapped := false
for each i in length( A ) - 2 down to 0 do
if A[ i ] > A[ i+1 ] then
swap( A[ i ], A[ i+1 ] )

pg. 9
 swapped := true;
while swapped; // if no elements have been swapped,
// then the list is sorted

6. RADIX SORT
Radix Sort adalah metode sorting yang ajaib yang mana mengatur pengurutan nilainya tanpa
melakukan beberapa perbandingan pada data yang dimasukkan. Secara umum proses yang dilakukan
dalam metode ini adalah mengklasifikasikan data sesuai dengan kategori terurut yang tertentu dan
dalam tiap kategorinya dilakukan pengklasifikasian lagi dan seterusnya sesuai dengan kebutuhan.
Secara kompleksitas waktu, radix sort termasuk ke dalam Divide and Conquer. Namun dari segi
algoritma untuk melakukan proses pengurutan, radix sort tidak termasuk dalam Divide and Conquer.

Jenis radix menggunakan penghitungan sortir untuk pengurutan O (N) yang efisien dari digit (k = 0 ...
9). Sebenarnya, radix sort berasal dari digit paling tidak signifikan (digit 1) sampai yang paling
signifikan. Jenis radix & counting cepat, namun membutuhkan data terstruktur, memori eksternal dan
tidak memiliki manfaat caching quicksort.

Pseudocode radix sort:

Radix-Sort(A, d)

//It works same as counting sort for d number of passes.

//Each key in A[1..n] is a d-digit integer.

//(Digits are numbered 1 to d from right to left.)

for j = 1 to d do

//A[]-- Initial Array to Sort

int count[10] = {0};

//Store the count of "keys" in count[]

//key- it is number at digit place j

for i = 0 to n do

count[key of(A[i]) in pass j]++

for k = 1 to 10 do

count[k] = count[k] + count[k-1]

pg. 10
 //Build the resulting array by checking

//new position of A[i] from count[k]

for i = n-1 downto 0 do

result[ count[key of(A[i])] ] = A[j]

count[key of(A[i])]--

//Now main array A[] contains sorted numbers

//according to current digit place

for i=0 to n do

A[i] = result[i]

end for(j)

end func

Berikut adalah contoh cara kerja radix sort:

pg. 11
7. PIGEONHOLE SORT
Pigeonhole Sort adalah algoritma pengurutan yang sesuai untuk menyortir daftar elemen dimana
jumlah elemen (n) dan jumlah nilai kunci yang mungkin (N) kira-kira sama. Hal ini membutuhkan waktu
O (n + Range) dimana n adalah jumlah elemen dalam array input dan 'Range' adalah jumlah nilai yang
mungkin dalam array.

Cara kerja untuk Pigeonhole Sortir:

- Temukan nilai minimum dan maksimum dalam array. Biarkan nilai minimum dan maksimum
menjadi 'min' dan 'max' masing-masing. Juga temukan range sebagai 'max-min-1'.
- Siapkan sederetan "pigeonholes" yang kosong awalnya dengan ukuran yang sama dengan
rentangnya.
- Kunjungi setiap elemen array dan letakkan setiap elemen di pigeonholenya. Masukan
elemen [i] diletakkan di lubang pada masukan indeks [i] - min.
- Jalankan lingkaran di seluruh array pigeonhole dalam urutan dan letakkan elemen dari
lubang yang tidak kosong kembali ke array aslinya.

Jenis Pigeonhole mirip dengan counting sort, jadi di sini adalah perbandingan antara Pigeonhole sort
dan Counting sort.

Contoh code pigeonhole sort:

#include <bits/stdc++.h>
using namespace std;

/* Sorts the array using pigeonhole algorithm */

void pigeonholeSort(int arr[], int n)
{
// Find minimum and maximum values in arr[]
int min = arr[0], max = arr[0];

pg. 12
 for (int i = 1; i < n; i++)
{
if (arr[i] < min)
min = arr[i];
if (arr[i] > max)
max = arr[i];
}
int range = max - min + 1; // Find range

// Create an array of vectors. Size of array

// range. Each vector represents a hole that
// is going to contain matching elements.
vector<int> holes[range];

// Traverse through input array and put every

// element in its respective hole
for (int i = 0; i < n; i++)
holes[arr[i]-min].push_back(arr[i]);

// Traverse through all holes one by one. For

// every hole, take its elements and put in
// array.
int index = 0; // index in sorted array
for (int i = 0; i < range; i++)
{
vector<int>::iterator it;
for (it = holes[i].begin(); it != holes[i].end(); ++it)
arr[index++] = *it;
}
}

// Driver program to test the above function

int main()
{
int arr[] = {8, 3, 2, 7, 4, 6, 8};
int n = sizeof(arr)/sizeof(arr[0]);

pigeonholeSort(arr, n);

printf("Sorted order is : ");

for (int i = 0; i < n; i++)
printf("%d ", arr[i]);

return 0;
}

8. BUCKET SORT
Bucket sort, atau bin sort, adalah algoritma pengurutan yang bekerja dengan mempartisi array
menjadi sejumlah ember. Setiap ember kemudian diurutkan secara terpisah, baik dengan
menggunakan algoritma pengurutan yang berbeda, atau secara rekursif menerapkan algoritma
sorting bucket. Ini adalah semacam distribusi, dan sepupu dari radix sort. Bucket sort dapat
diimplementasikan dengan perbandingan dan oleh karena itu juga dapat dianggap sebagai algoritma
sortasi perbandingan. Perkiraan kompleksitas komputasi melibatkan jumlah ember.

pg. 13
Bucket sort bekerja sebagai berikut:

Cari nilai maksimum dan minimum di dalam array.

Inisialisasi array bucket Daftar <> unsur (ukuran maxValue minValue + 1)
Siapkan sederetan "bucket/ember" yang kosong.
Scatter: Pergi ke array asli, menempatkan setiap objek dalam ember nya.
Urutkan setiap ember yang tidak kosong.
Gather: Kunjungi ember dalam rangka dan letakkan semua elemen kembali ke array aslinya.

Berikut ini adalah 2 gambar contoh cara kerja / algoritma bucket sort:

pg. 14
Contoh implementasi:
//#include <algorithm>
//#include <vector>

// Function to sort arr[] of size n using bucket sort

void bucketSort(float arr[], int n)
{
// 1) Create n empty buckets
vector b[n];

// 2) Put array elements in different buckets

for (int i=0; i<n; i++)
{
int bi = n*arr[i]; // Index in bucket
b[bi].push_back(arr[i]);
}

// 3) Sort individual buckets

for (int i=0; i<n; i++)
sort(b[i].begin(), b[i].end());

// 4) Concatenate all buckets into arr[]

int index = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < b[i].size(); j++)
arr[index++] = b[i][j];
}

Analis:
Jika kita asumsikan bahwa penyisipan dalam sebuah bucket membutuhkan waktu O (1) maka langkah
1 dan 2 dari algoritma di atas dengan jelas mengambil waktu O (n). O (1) mudah dilakukan jika kita
menggunakan linked list untuk mewakili ember (Dalam kode di atas, vektor C ++ digunakan untuk
kesederhanaan). Langkah 4 juga mengambil O (n) waktu karena akan ada n item di semua ember.
Langkah utama untuk dianalisis adalah langkah 3. Langkah ini juga memakan waktu O (n) rata-rata jika
semua nomor terdistribusi secara merata.

pg. 15
Auxiliary Space: O (n.k)
Sorting In Place: Tidak
Stabil: Ya

Bucket sort dengan dua ember secara efektif merupakan versi quick sort dimana nilai pivot selalu
dipilih menjadi nilai tengah dari kisaran nilai. Sementara pilihan ini efektif untuk input yang
terdistribusi secara merata, cara lain untuk memilih pivot secara cepat seperti pivot yang dipilih secara
acak membuatnya lebih tahan terhadap pengelompokan dalam distribusi input.

N-jalan algoritma merge sort juga dimulai dengan mendistribusikan daftar ke dalam n sublists dan
memilah masing-masing; Namun, sublists yang dibuat oleh gabungan semacam memiliki rentang nilai
yang tumpang tindih dan karenanya tidak dapat digabungkan kembali dengan rangkaian sederhana
seperti dalam jenis ember. Sebagai gantinya, mereka harus disisipkan oleh algoritma penggabungan.
Namun, biaya tambahan ini diimbangi dengan fase pencemaran yang lebih sederhana dan
kemampuan untuk memastikan bahwa setiap subdaftar memiliki ukuran yang sama, memberikan
waktu terburuk untuk terikat.

Top-down radix sort dapat dilihat sebagai kasus khusus dari jenis bucket sort di mana rentang nilai
dan jumlah ember dibatasi menjadi kekuatan dua. Akibatnya, setiap ukuran ember juga merupakan
kekuatan dua, dan prosedurnya bisa diterapkan secara rekursif. Pendekatan ini dapat mempercepat
fase penyebaran, karena kita hanya perlu memeriksa awalan representasi bit dari setiap elemen untuk
menentukan embernya.

9. COUNTING SORT
Counting sort adalah algoritma yang efisien untuk menyortir array elemen yang masing-masing
memiliki kunci bilangan bulat nonnegatif, misalnya, sebuah array, yang biasa disebut list, bilangan
bulat positif dapat memiliki kunci yang hanya nilai integer sebagai kunci, atau daftar kata bisa memiliki
kunci yang ditugaskan kepada mereka oleh beberapa skema pemetaan alfabet ke bilangan bulat
(untuk mengurutkan menurut abjad, misalnya). Tidak seperti algoritma pengurutan lainnya, seperti
mergesort, counting sort adalah algoritma sortasi integer, bukan algoritma berbasis perbandingan.
Sementara algoritma sortasi berbasis perbandingan memerlukan (n lg n) perbandingan, counting
sort memiliki running time (n) ketika panjang list masukan tidak jauh lebih kecil daripada nilai kunci
terbesar, dalam list. Counting sort dapat digunakan sebagai subrutin untuk algoritma sortir lain yang
lebih kuat seperti sort radix.

Dalam counting sort dilakukan:

Membuat array count adalah O (N)
Memasukkan items ke posisi semula adalah O (N)

pg. 16
Contoh cara kerja counting sort:

pg. 17
pg. 18
pg. 19
pg. 20
pg. 21
pg. 22
pg. 23
pg. 24
pg. 25
pg. 26
Pseudocode counting sort:

CountingSort(A)

//A[]-- Initial Array to Sort

//Complexity: O(k)

for i = 0 to k do

c[i] = 0

//Storing Count of each element

pg. 27
 //Complexity: O(n)

for j = 0 to n do

c[A[j]] = c[A[j]] + 1

// Change C[i] such that it contains actual

//position of these elements in output array

////Complexity: O(k)

for i = 1 to k do

c[i] = c[i] + c[i-1]

//Build Output array from C[i]

//Complexity: O(n)

for j = n-1 downto 0 do

B[ c[A[j]]-1 ] = A[j]

c[A[j]] = c[A[j]] - 1

end func

10. TIM SORT

Timsort adalah algoritma hibrida yang menggabungkan gabungan sort dan insert sort, berdasarkan
fakta sederhana bahwa sebagian besar data dalam praktik sebagian dipesan (naik atau turun).
Algoritma pengurutan Timsort yang didefinisikan dalam array segmen yang dipesan untuk dijalankan,
masing-masing dijalankan memerlukan peningkatan monoton atau penurunan monoton secara ketat
(untuk memastikan stabilitas algoritma), seperti yang ditunjukkan di bawah ini

Dengan beberapa detail di samping, algoritma sorting Timsort dapat diringkas dalam dua tahap:

Langkah pertama adalah mengatur susunan yang akan diatur menjadi run, tentu saja, run tidak boleh
terlalu pendek, jika panjangnya kurang dari ambang min-run, maka gunakan insert sort untuk melebar.

pg. 28
Langkah kedua akan berjalan ke tumpukan, ketika bagian atas tumpukan berjalan panjang tidak
memenuhi salah satu kendala berikut,

runLen [n-2]> runLen [n-1] + runLen [n]

runLen [n-1]> runLen [n]

Penggunaan gabungan semacam akan menjadi yang terpendek dari dua run ke run baru, tumpukan
akhir ketika pesanan selesai.

Di bawah contoh untuk diilustrasikan, dalam contoh ini kita menetapkan min-run = 4, yang berarti
panjang run minimum tidak boleh kurang dari 4. Terbagi dalam lari ke tumpukan, seperti yang
ditunjukkan di bawah ini

(pesanan terbalik)

Perhatikan bahwa run di bagian atas stack tidak memenuhi kendala saat ini, karena runLen [0]<runLen
[1] saat ini, jadi anda ingin menggabungkan dua run, tentu saja, proses ini menggunakan gabungan
sort.

Jika Anda menemukan fragmen fragmen yang teratur kurang dari minrun, itu harus diisi, seperti
gambar di bawah ini

(pesanan terbalik)

pg. 29
Keterangan gambar:

* : (panjangnya kurang dari 4, berapa bedanya, berikut ini adalah penggunaan insertion sort.)

Perhatikan bahwa run-time di bagian atas tumpukan memenuhi batasan 10> 5 + 4, 5> 4, jadi tidak
perlu digabungkan.

Jumlah elemen terakhir kurang dari array minrun, hanya sebagai run

Keterangan gambar:

* : (hanya 2 elemen yang tersisa, secara otomatis sebagai satu run)

Pada titik ini bagian atas run tidak memenuhi batasan run, 5 <4 +2, jadi kebutuhan untuk
penggabungan. Proses follow up seperti yang ditunjukkan di bawah ini

(urut)

(urut)

(urut)

pg. 30
Pseudocode tim sort:
static int minRunLength ( int n) {
assert n> = 0;
int r = 0; // Becomes 1 if any 1 bits are off off
while (n> = MIN_MERGE) {
r | = (n & 1);
n >> = 1;
}
return n + r;
}

pg. 31
 TABEL RUNNING TIME 10 ALGORITMA SORTING
(DARI YANG PALING LAMA KE YANG PALING CEPAT)
ALGORITMA STABIL RUNNING TIME CATATAN
Exchange sort Ya O(N2) Exchange sort membandingkan suatu elemen
dengan elemen-elemen lainnya dalam array
tersebut, dan melakukan pertukaran elemen jika
perlu. Jadi ada elemen yang selalu menjadi elemen
pusat (pivot).

Comb sort Tidak O(N2) Lebih cepat dari bubble sort dari rata-rata running
timenya.
Heap sort Tidak O(N log N) Mirip dengan selection sort, tetapi lebih baik untuk
mendapatkan elemen terbesar. Heapsort mencari
elemen terbesar, lalu meletakkannya pada heap.
Termasuk comparison sort.
Shell sort Tidak O(N log N) Ukuran kode kecil, tidak ada penggunaan call stack,
cukup cepat, berguna dimana memori berada pada
premium seperti aplikasi mainframe yang
disematkan dan yang lebih tua. Best case n log n
dan worst case n log n tidak dapat dicapai
bersamaan. Dengan kasus terbaik n log n, kasus
terburuk adalah n / . Termasuk comparison sort.
Cocktail sort Ya O(N) Variasi dari Bubble sort. Algoritma Bubble sort
selalu melintasi elemen dari kiri dan memindahkan
elemen terbesar ke posisi yang benar pada iterasi
pertama dan kedua terbesar pada iterasi kedua dan
seterusnya. Cocktail Sort melintasi melalui array
yang diberikan di dua arah sebagai alternatif.
Radix sort Ya O(N) Radix Sort adalah metode sorting yang ajaib yang
mana mengatur pengurutan nilainya tanpa
melakukan beberapa perbandingan pada data yang
dimasukkan. Secara umum proses yang dilakukan
dalam metode ini adalah mengklasifikasikan data
sesuai dengan kategori terurut yang tertentu dan
dalam tiap kategorinya dilakukan pengklasifikasian
lagi dan seterusnya sesuai dengan kebutuhan.
Termasuk non-comparison sort.
Pigeonhole sort Ya O(N) Pigeonhole Sort adalah algoritma pengurutan yang
sesuai untuk menyortir daftar elemen dimana
jumlah elemen (n) dan jumlah nilai kunci yang
mungkin (N) kira-kira sama.
Bucket sort Ya O(N) Jika range data yang akan diurutkan adalah O(N),
maka kompleksitas waktu rata-rata adalah O (n).
Termasuk non-comparison sort.
Counting sort Ya O(N) Jika range data yang akan diurutkan adalah O(N),
maka kompleksitas waktu rata-rata adalah O (n).
Termasuk non-comparison sort.
Tim sort Ya O(N) Membuat n perbandingan saat data sudah disortir
atau disortir ulang.

pg. 32
SUMBER:
https://en.wikipedia.org/wiki/Sorting_algorithm
http://brainchild.tistory.com/entry/Pseudocode-concept-Exchange-
Sort%EA%B5%90%ED%99%98%EC%A0%95%EB%A0%AC
http://hwsmartsolution.com/blog/2016/02/02/exchange-sort-dengan-bahasa-c/
https://www.researchgate.net/profile/Ashraf_Maghari/publication/314753240_A_comparative_Stu
dy_of_Sorting_Algorithms_Comb_Cocktail_and_Counting_Sorting/links/58c57219aca272e36dda981
b/A-comparative-Study-of-Sorting-Algorithms-Comb-Cocktail-and-Counting-Sorting.pdf
http://wikistack.com/comb-sort-in-c/
https://en.wikipedia.org/wiki/Comb_sort
http://www.oxfordmathcenter.com/drupal7/node/111
https://cstheory.stackexchange.com/questions/9619/analysis-of-comb-sort
http://www.robasworld.com/sorting-algorithms/
https://samudrapasific.wordpress.com/2014/10/22/macam-macam-sorting-algoritma/
http://www.algorithmist.com/index.php/Heap_sort
http://book.huihoo.com/data-structures-and-algorithms-with-object-oriented-design-patterns-in-
c++/html/page518.html
https://www.codingeek.com/algorithms/radix-sort-explanation-pseudocode-and-implementation/
https://en.wikibooks.org/wiki/Algorithm_Implementation/Sorting/Pigeonhole_sort
http://www.geeksforgeeks.org/pigeonhole-sort/
https://www.codeday.top/2017/09/11/40687.html
http://codersmaze.com/sorting/bucket-sort/
http://javarevisited.blogspot.co.id/2017/01/bucket-sort-in-java-with-example.html
http://bigocheatsheet.com/
http://khan4019.github.io/front-end-Interview-Questions/sort.html
https://arxiv.org/abs/1206.3511
https://www.quora.com/Algorithms-What-is-the-difference-between-Radix-sort-Bucket-sort-and-
Counting-sort
https://www.slideshare.net/sarveshdav/algo-ppt
https://brilliant.org/wiki/counting-sort/
http://java4rookie.blogspot.co.id/2014/02/counting-sort-explanation.html
https://www.codingeek.com/algorithms/counting-sort-explanation-pseudocode-and-
implementation/
http://codenza.us/explanations/cocktail-sort/54680/
http://www.geeksforgeeks.org/cocktail-sort/

pg. 33
https://bindog.github.io/blog/2015/03/30/use-formal-method-to-find-the-bug-in-timsort-and-lunar-
rover/
http://xieyan87.com/2015/08/timsort%E7%AE%97%E6%B3%95%E7%AE%80%E4%BB%8B/

pg. 34