SORTING

Pengertian Algoritma Pengurutan (Sorting)

Dalam ilmu computer, algoritma pengurutan adalah
 Algoritma yang meletakkan elemen-elemen suatu kumpulan data dalam urutan tertentu.
 Proses pengurutan data yang sebelumnya disusun secara acak sehingga menjadi tersusun
secara teratur menurut suatu aturan tertentu.

Sorting adalah proses menyusun elemen-elemen dengan tata urut tertentu dan proses tersebut
terimplementasi dalam bermacam aplikasi. Contohnya pada perbankan. Aplikasi tersebut mampu
menampilkan daftar account yang aktif. Hampir seluruh pengguna pada sistem akan memilih tampilan
daftar berurutan secara ascending demi kenyamanan dalam penelusuran data.

Yang pada kenyataannya ‘urutan tertentu’ yang umum digunakan adalah secara terurut secara
numerical ataupun secara leksikografi (urutan secara abjad sesuai kamus). Ada 2 jenis sorting:
Ascending (naik) & Descending (turun).

Klasifikasi Algoritma Pengurutan (Sorting):

 Exchange Sort
Melakukan pembandingan antar data, dan melakukan pertukaran apabila urutan yang
didapat belum sesuai.
Contoh: Bubble Sort, Cocktail Sort, Comb Sort, Gnome Sort, Quick Sort.

 Selection Sort
Mencari elemen yang tepat untuk diletakkan di posisi yang telah diketahui, dan
meletakkannya di posisi tersebut setelah data tersebut ditemukan.
Contoh: Selection Sort, Heapsort, Smoothsort, Strand Sort.

 Insertion Sort
Mencari tempat yang tepat untuk suatu elemen data yang telah diketahui ke dalam sub
kumpulan data yang telah terurut, kemudian melakukan penyisipan (insertion) data di
tempat yang tepat tersebut.
Contoh: Insertion Sort, Shell Sort, Tree Sort, Library Sort, Patience Sorting.

 Merge Sort
Data dibagi menjadi sub kumpulan – sub kumpulan yang kemudian sub kumpulan tersebut
diurutkan secara terpisah, dan kemudian digabungkan kembali dengan metode merging.
Algoritma ini melakukan metode pengurutan merge sort juga untuk mengurutkan sub
kumpulan data tersebut, atau dengan kata lain, pengurutan dilakukan secara rekursif.
Contoh: Merge Sort.

 Non-Comparison Sort
Proses pengurutan data yang dilakukan algoritma ini tidak terdapat pembandingan antar
data, data diurutkan sesuai dengan pigeon hole principle.

1
Metode Sorting
1. Radix Sort
Ide dasar dari metode Radix Sort ini adalah mengkategorikan data-data menjadi sub
kumpulan – sub kumpulan data sesuai dengan nilai radix-nya, mengkonkatenasinya,
kemudian mengkategorikannya kembali berdasar nilai radix lainnya.
Contoh implementasi yang akan dilakukan adalah implementasi pada bilangan bulat
positif menggunakan salah satu algoritma pengurutan radix sort. Contohnya adalah
pengurutan sebuah kumpulan data bilangan bulat dengan jumlah digit maksimal 3.

121 076 823 367 232 434 742 936 274

121 076 823 367 232 434 742 936 274

Kategori digit Isi

0 -
1 121
2 232, 742
3 823
4 434, 274
5 -
6 076, 936
7 367
8 -
9 -

Hasil pengkategorian tersebut lalu digabung kembali dengan metode konkatenasi

menjadi :

121 232 742 823 434 274 076 936 367

Kemudian pengkategorian dilakukan kembali, nmaun kali ini berdasar digit kedua atau
digit tengah, dan jangan lupa bahwa urutan pada tiap sub kumpulan data harus sesuai
dengan urutan kemunculan pada kumpulan data.

121 232 742 823 434 274 076 936 367

Kategori digit Isi

0 -
1 -
2 121, 823
3 232, 434, 936
4 742
5 -
6 367
7 274, 076
8 -
9 -

Yang kemudian dikonkatenasi kembali menjadi

121 823 232 434 936 742 367 274 076

2
 Kemudian langkah ketiga, atau langkah terakhir pada contoh ini adalah pengkategorian
kembali berdasar digit yang terkiri, atau yang paling signifikan.

121 823 232 434 936 742 367 274 076

Kategori digit Isi

0 076
1 121
2 232, 274
3 367
4 434
5 -
6 -
7 742
8 823
9 936

Yang kemudian dikonkatenasi lagi menjadi

076 121 232 274 367 434 742 823 936

Yang merupakan hasil akhir dari metode pengurutan ini. Di mana data telah terurut
dengan metode radix sort.

Algoritma dan Kompleksitas Waktu Radix Sort

Implementasi dari algoritma tersebut dibuat menggunakan bahasa Pascal, yang
direalisasikan dengan menggunakan queue sebagai representasi tiap kategori radix
untuk pengkategorian. Array A adalah array input, dan array B adalah array A yang
terurut.

Procedure RadixSort (A : TArray; var B : TArray; d : byte);

var
KatRadix : array [0..9] of Queue;
i, x, ctr : integer;
pembagi : longword;
begin
{--- mengkopi A ke B ---}
for i:=1 to n do
B[i] := A[i];

pembagi := 1;
for x:=1 to d do begin
{--- inisialisasi KatRadix ---}
for i:=0 to 9 do
InitQueue (KatRadix[i]);
{--- dikategorikan ---}
for i:=1 to n do
Enqueue (KatRadix [(B[i] div pembagi) mod 10], B[i]);
B[i] := 0;
{--- dikonkat ---}

3
 ctr := 0;
for i:=0 to 9 do begin
while (NOT IsQueueEmpty (KatRadix[i])) do begin ctr := ctr
+ 1;
B[ctr]:=DeQueue (KatRadix [i]);
end;
end;
pembagi := pembagi * 10;
end;
end;

2. Bubble Sort
Cara kerja Bubble Sort:
1. Algoritma dimulai dari elemen paling awal.
2. 2 buah elemen pertama dari list data dibandingkan.
3. Jika elemen pertama > elemen kedua, dilakukan pertukaran.
4. Langkah 2 dan 3 dilakukan lagi terhadap elemen kedua dan ketiga, seterusnya sampai ke
ujung elemen.
5. Bila sudah sampai di ujung dilakukan lagi ke awal sampai tidak ada terjadi lagi
pertukaran elemen.
6. Bila tidak ada pertukaran elemen lagi, maka list elemen sudah terurut.

Algoritma Bubble Sort

Setiap pasangan data: x[j] dengan x[j-1], untuk semua i=1, …, n-1 harus memenuhi
keterurutan yaitu x[j] > x[j-1]. Apabila tidak memenuhi maka posisi kedua data harus ditukar.
Untuk pemrograman konvensional maka pemeriksaan-pemeriksaan pasangan tersebut harus
dilakukan satu demi satu, misalnya oleh bubble-sort dilakukan dari kanan ke kiri serta di
dalam sejumlah iterasi. Pada iterasi ke-i, pemeriksaan tersebut dilakukan pula dalam loop-for
sebagai berikut

deskripsi
adatukar ← true
I ← 1
While (I<n) and (adatukar) do
j ← 1
Adatukar ← false
While j <= (n-I) do
If x[j] > x[j+1] then
Adatukar ← true
temp ← x[j]
X[j] ← x[j+1]
x[j+1] ← temp
endif
j ← j+1
endwhile
i ← i+1
endwhile

Loop-for tersebut akan menggeser bilangan terkecil ke posisi i. Loop-for dilakukan

hanya sampai ke i karena pada iterasi ke-i data dalam x[0], x[1], …, x[i-1] merupakan yang
paling kecil dan sudah terurut hasil pergeseran yang dilakukan setiap loop sebelumnya. Oleh

4
sebab itu iterasi hanya dilakukan untuk harga i=0, 1, …, n-2 atau sampai tidak terjadi
penukaran dalam suatu iterasi.

Pada gambar di bawah ini, pengecekan dimulai dari data yang paling akhir, kemudian
dibandingkan dengan data di depannya, jika data di depannya lebih besar maka akan ditukar.

Pada proses kedua, pengecekan dilakukan sampai dengan data ke-2 karena data
pertama pasti sudah paling kecil.

5
 Keuntungan lain dari algoritma ini adalah dapat dijalankan dengan cukup cepat dan
efisien untuk mengurutkan list yang urutannya sudah hamper benar. Selain kasus terbaik
tersebut, kompleksitas untuk algoritma ini adalah O(n 2). Karenanya algoritma ini termasuk
sangat tidak efisien untuk dilakukan, apalagi jika pengurutan dilakukan terhadap elemen
yang banyak jumlahnya. Biasanya bubble sort digunakan untuk mengenalkan konsep dari
sorting algoritma pada pendidikan computer karena idenya cukup sederhana.

3. Selection Sort
Metode selection sort merupakan perbaikan dari metode bubble sort dengan mengurangi
jumlah perbandingan. Selection sort merupakan metode pengurutan yang mencari nilai data
terbesar atau terkecil dan kemudian menempatkannya pada posisi yang sebenarnya, dimulai
dari data di posisi 0 hingga data di posisi n-1.
Sedangkan metode insertion sort adalah metode pengurutan yang biasa dipakai oleh
pemain kartu dalam mengurutkan kartunya, yaitu menyisipkan kartu dengan nilai yang lebih
kecil ke posisi sebelum kartu pembandingnya.
Selection sort merupakan kombinasi antara sorting dan searching. Untuk setiap proses,
akan dicari elemen-elemen yang belum diurutkan yang memiliki nilai terkecil atau terbesar
akan dipertukarkan ke posisi yang tepat di dalam array. Misalnya untuk putaran pertama,
akan dicari data dengan nilai terkecil dan data ini akan ditempatkan di indeks terkecil
(data[0]), pada putaran kedua akan dicari data kedua terkecil, dan akan ditempatkan di
indeks kedua (data[1]).
Selama proses, pembandingan dan pengubahan hanya dilakukan pada indeks
pembanding saja, pertukaran data secara fisik terjadi pada akhir proses. Teknik pengurutan
dengan cara pemilihan elemen atau proses kerja dengan memilih elemen data terkecil untuk
kemudian dibandingkan dan ditukarkan dengan elemen pada data awal, dan seterusnya
sampai dengan seluruh elemen sehingga akan menghasilkan pola data yang telah disort.

6
Cara Kerja Algoritma Selection Sort
Bagaimana cara kerja dari algoritma selction sort? Berikut adalah langkah perlangkah
cara kerja dari algoritma yang bekerja pada suatu elemen array.
1. Tetapkan suatu indeks yang akan dijadikan awal dari sorting, biasanya indeks pada awal
array.
2. Jika akan dilakukan sorting secara ascending maka cari elemen yang paling kecil dengan
membandingkan dengan nilai indeks yang dijadikan patokan. Lakukan hal yang
sebaliknya jika akan melakukan sorting secara descending.
3. Jika ada nilai yang memenuhi dari langkah b maka lakukan pertukaran indeks yang
dijadikan patokan.
4. Hasil akhir dari langkah c adalah didapat nilai indeks yang terkecil(jika ascending)
kemudian tukarkan nilai indeks tersebut dengan nilai indeks yang paling ujung dari
elemen yang belum terurut.
5. Lakukan langkah-langkah di atas hingga didapatkan elemen array yang telah terurut.

Kelebihan dan Kekurangan Selection Sort:

 Kompleksitas selection sort relatif lebih kecil.
 Mudah menggabungkannya kembali, tetapi sulit membagi masalah.
 Membutuhkan method tambahan

Kondisi awal:
 Unsorted list = data
 Sorted list = kosong

Ambil yang terbaik (select) dari unsorted list, tambahkan di belakang sorted list.
Lakukan terus sampai unsorted list habis.

7
Sebuah contoh :

Algortimanya:
void selectionSort(Object array[], int startIdx, int endIdx) {
int min;
for (int i = startIdx; i < endIdx; i++) {
min = i;
for (int j = i + 1; j < endIdx; j++) {
if (((Comparable)array[min]).compareTo(array[j])>0)
{
min = j;
}
}
swap(array[min], array[i]);
}
}

Berikut adalah contoh pseudocode dari algoritma selection sort

Procedure SelectionSort(Input/Output T: TabInt, Input N:integer)
{
Mengurut tabel integer [1 .. N] dengan Selection Sort secara
ascending
}

Kamus:
I : integer
Pass : integer
Min : integer

8
 Temp : integer

Algoritma:
Pass traversal [1..N-1’
Min  Pass
I traversal [Pass+1..N]
If (Ti < Tmin) then
Min  j
Temp  TPass
TPass  Tmin
Tmin  Temp
{T[1..Pass] terurut}

Contoh Algoritma Selection Sort pada Java

Untuk mengimplementasikan algoritma selection sort, kita dapat membuat dua class.
Yang pertama adalah class SelectionSort yang di dalamnya terdapat method sort() yang berisi
algoritma selection sort. Berikut adalah kode program lengkapnya.

public class SelectionSort {

protected static void sort(int[] arr) {
for (int i=0; i<arr.length; i++){
int min=i;
for (int j=0; j<arr.length; j++) {
if (arr[j]<arr[min])
min=j;
//proses pertukaran
int temp=arr[min];
arr[min]=arr[i];
arr[i]=temp;
}
}
}
}

Untuk menjalankan class SelectionSort kita membutuhkan sebuah class yang berisi
method main yang berfungsi sebagai titik awal program java berjalan. Berikut kode
programnya.

public class DemoSelectionSort {

public static void main(String[] args) {
int[]data={6,13,1,2,8};
System.out.println("Sebelum Proses Sorting...");
tampil(data);
SelectionSort.sort(data);
System.out.println("Sesudah Sorting...");
tampil(data);
}
static void tampil(int[]arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
}

9
 }

Kode program di atas adalah class DemoSelectionSort yang fungsinya sebagai class
utama. Terdapat dua buah method yakni method main dan method tampil yang berfungsi
untuk menampilkan elemen array melalui suatu proses iterasi.

Hasil yang kita dapatkan ketika class DemoSelectionSort ini dijalankan:

Output Selection Sort

4. Insertion Sort
Prinsip dasar Insertion adalah secara berulang-ulang menyisipkan/memasukkan setiap
elemen ke dalam posisi/tempatnya yang benar. Mirip dengan cara orang mengurutkan
kartu, selembar demi selembar kartu diambil dan disisipkan (insert) ke tempat yang
seharusnya. Pengurutan dimulai dari data ke-2 sampai dengan data terakhir, jika ditemukan
data yang lebih kecil, maka akan ditempatkan (di-insert) di posisi yang seharusnya. Pada
penyisipan elemen, maka elemen-elemen lain akan bergeser ke belakang.
Berikut ini penjelasan mengenai bagaimana algoritma insertion sort bekerja dalam
pengurutan kartu
 Anggaplah anda ingin mengurutkan satu set kartu dari kartu yang bernilai paling kecil
hingga paling besar.
 Seluruh kartu diletakkan pada meja, sebutlah meja ini sebagai meja pertama, disusun
dari kiri ke kanan dan atas ke bawah.
 Kemudian terdapat meja lain, meja kedua, di mana kartu yang diurutkan akan
diletakkan.
 Ambil kartu pertama yang terletak pada pojok kiri atas meja pertama dan letakkan pada
meja kedua.
 Ambil kartu kedua dari meja pertama, bandingkan dengan kartu yang berada pada meja
kedua, kemudian letakkan pada urutan yang sesuai setelah perbandingan.
 Proses tersebut akan berlangsung hingga seluruh kartu pada meja pertama telah
diletakkan berurutan pada meja kedua

Algoritma insertion sort pada dasarnya memilah data yang akan diurutkan menjadi dua
bagian, yang belum diurutkan (meja pertama) dan yang sudah diurutkan (meja kedua).
Elemen pertama diambil dari bagian array yang belum diurutkan dan kemudian diletakkan
sesuai posisinya pada bagian lain dari array yang telah diurutkan. Langkah ini dilakukan
secara berulang hingga tidak ada lagi elemen yang tersisa pada bagian array yang belum
diurutkan.
Kondisi awal
 Unsorted list = data
 Sorted list = kosong

10
 Ambil sembarang elemen dari unsorted list, sisipkan (insert) pada posisi yang benar
dalam sorted list. Lakukan terus sampai unsorted list habis. Bayangkan anda mengurutkan
kartu.

Sebuah Contoh 1:

Algoritma Insertion Sort:

void insertionSort(Object array[], int startIdx, int endIdx) {
for (int i = startIdx; i < endIdx; i++) {
int k = i;

11
 for (int j = i + 1; j < endIdx; j++) {
if (((Comparable) array[k]).compareTo(array[j])>0) {
k = j;
}
}
swap(array[i],array[k]);
}
}

Sebuah Contoh 2:

5. Quick Sort
Quicksort ditemukan oleh C.A.R Hoare. Seperti pada merge sort, algoritma ini juga
berdasar pada pola divide-and-conquer. Berbeda dengan merge sort, algoritma ini hanya
mengikuti langkah-langkah sebagai berikut:

1. Divide
Memilah rangkaian data menjadi dua sub-rangkaian A[p…q-1] dan A[q+1…r] di
mana setiap elemen A[p…q-1] adalah kurang dari atau sama dengan A[q] dan setiap
elemen pada A[q+1…r] adalah lebih besar atau sama dengan elemen pada A[q].
A[q] disebut sebagai elemen pivot. Perhitungan pada elemen q merupakan salah
satu bagian dari prosedur pemisahan

2. Conquer
Mengurutkan elemen pada sub-rangkaian secara rekursif

Pada algoritma quicksort, langkah “kombinasi” tidak dilakukan karena telah terjadi
pengurutan elemen-elemen pada sub-array.

Quick sort banyak digunakan untuk proses sorting, karena:

 Merupakan proses sorting yang umum digunakan
 Mudah untuk diimplementasikan
 Prosesnya sangat cepat

Algoritma Quick Sort :

deskripsi
x ← data[(L+R) div 2]
I ← L
J ← R
while ( I < = J ) do
while (data[I] < x ) do inc( I ) endwhile

12
 while ( data[J] > x ) do dec( J ) endwhile
If ( I < = J ) then
tukar(data[I],data[j])
inc( I )
Dec( J )
endif
endwhile
If ( L < J ) then quicksort(larikpixel, L, J )
If ( I < R ) then quicksort(larikpixel, I, R )

Sebuah Contoh 1:
Rangkaian data:

Pilih sebuah elemen yang akan menjadi elemen pivot.

Inisialisasi elemen kiri sebagai elemen kedua dan elemen kanan sebagai elemen akhir.

Geser elemen kiri ke arah kanan sampai ditemukan nilai yang lebih besar dari elemen pivot
tersebut. Geser elemen kanan kea rah kiri sampai ditemukan nilai dari elemen yang tidak
lebih besar dari elemen tersebut.

Tukarkan antara elemen kiri dan kanan

Geserkan lagi elemen kiri dan kanan.

Tukarkan antar elemen kembali.

Geserkan kembali elemen kiri dan kanan.

Terlihat bahwa titik kanan dan kiri telah digeser sehingga mendapatkan nilai elemen kanan <
elemen kiri. Dalam hal ini tukarkan elemen pivot dengan elemen kanan.

13
Kemudian urutkan elemen sub-rangkaian pada setiap sisi dari elemen pivot.

Algoritma Quick Sort Contoh 1:

void quickSort(Object array[], int leftIdx, int rightIdx) {
int pivotIdx;
/* Kondisi Terminasi */
if (rightIdx > leftIdx) {
pivotIdx = partition(array, leftIdx, rightIdx);
quickSort(array, leftIdx, pivotIdx-1);
quickSort(array, pivotIdx+1, rightIdx);
}
}

Sebuah Contoh 2:

28

15 47

Ambil sebuah pivot, kemudian bagi menjadi 2 bagian yaitu bagian yang kurang dari dan
bagian yang lebih dari pivot. Urutkan masing-masing bagian secara rekursif.

Aturan Quick Sort:

o Select
Pertama pilih elemen yang di tengah sebagai pivot, misalkan X.

14
 o Partition
Kemudian semua elemen tersebut disusun dengan menempatkan X pada posisi j
sedemikian rupa sehingga elemen di sebelah kiri lebih kecil dari X dan elemen di
sebelah kanan lebih besar dari X.

o Rekursif
Kemudian proses diulang untuk bagian kiri dan kanan elemen X dengan cara yang
sama dengan langkah 1 sampai kondisi terurut.

Algoritma Quick Sort Contoh 2:

Misal diberikan sebuah array A memiliki n elemen (integer)  p = 0; r = n-1
a) Array A[p…r] dipartisi menjadi dua non-empty subarray:

A[p…q] and A[q+1…r]

Seluruh elemen dalam array A[p…q] lebih kecil dari seluruh elemen dalam array
A[q+1…r].

b) Seluruh sub array diurutkan secara rekursif dengan cara memanggil fungsi
quicksort().

Quicksort(A, p, r)
{
If (p < r)

15
 {
q = Partition(A, p, r);
Quicksort(A, p, q);
Quicksort(A, q+1, r);
}
}

Terlihat bahwa, seluruh aksi terjadi dalam fungsi partition(). Hasil akhirnya :
berupa dua subarray dan seluruh elemen pada subarray pertama ≤ seluruh elemen pada
subarray kedua. Kembalikan hasil berupa indeks dari elemen pivot yang memisahkan kedua
subarray tersebut.
Partition(A, p, r):
c) Pilih sebuah elemen yang bertindak sebagai pivot
d) Pecah array menjadi dua bagian. A[p…i] dan A[j…r]
 Seluruh elemen dalam A[p…i] < = pivot
 Seluruh elemen dalam A[j…r] > = pivot
e) Increment i until A[i] >= pivot
f) Decrement j until A[j] <= pivot
g) Jika i < j, maka Swap A[i] dan A[j]
h) Jika tidak, return j
i) Repeat until i >= j

Partition(A, p, r)
x = A[p]; //pivot=elemen posisi pertama
i = p; //inisialisasi
j = r;
repeat
while(A[j] > x)
j--;
while(A[i] < x)
i++;
if (i < j) {
Swap(A, i, j);
j--;
i++;
}
else
return j;
until i >= j

16
 Sebuah Contoh 3:

X = PIVOT merupakan indeks ke – 0.

PIVOT = 12, terdapat variable I dan j, i=0, j=9
Variable i untuk mencari bilangan yang lebih besar dari atau sama dengan PIVOT. Cara
kerjanya: selama Data[i] < PIVOT maka nilai i ditambah.
Variable j untuk mencari bilangan yang lebih kecil dari atau sama dengan PIVOT. Cara
kerjanya: selama Data[j] > PIVOT maka nilai j dikurangi.

17
PIVOT = 11
i = 2, j = 1
i < j NO SWAP
Return j = 1
Q = Partisi = 1

PIVOT = 35
i = 3, j = 9
i < j SWAP

18
 PIVOT = 20
i = 6, j = 5
i < j NO SWAP
Return j = 5
Q = Partisi = 5

3 9

19
 3 9 11 12 15 17 20 23 31 35

PIVOT = 23
i = 7, j = 6
i < j NO SWAP
Return j = 6
Q = Partisi = 6

PIVOT = 23
i = 7, j = 7
i < j NO SWAP
Return j = 7
Q = Partisi = 7

20
 q=1

q=4
QS(4,4) QS(5,5) QS(7,7) QS(8,8)

Jika diasumsikan pivot diambil secara random, terdistribusi secara uniform.

Best case running time: O(n log2n)

Pada setiap pemanggilan rekursif, posisi elemen pivot selalu persis di tengah, array
dipecah menjadi dua bagian yang sama, elemen-elemen yang lebih kecil dan yang lebih besar
dari pivot.

Worst case: O(N2)

Pada setiap pemanggilan rekursif, pivot selalu merupakan elemen terbesar (atau
terkecil); array dipecah menjadi satu bagian yang semua elemennya lebih kecil dari pivot,
pivot, dan sebuah bagian lagi array yang empty.

6. Heap Sort
Adalah binary tree dengan menggunakan kunci, dimana mempunyai aturan-aturan
sebagai berikut:
o Untuk mengisikan heap dimulai dari level 1 sampai ke level di bawahnya, bila
dalam level yang sama semua kunci heap belum terisi maka tidak boleh mengisi di
bawahnya.
o Heap dalam kondisi terurut apabila left child < parent dan right child > parent.
o Penambahan kunci diletakkan pada posisi terakhir dari level dan di sebelah kanan
child yang terakhir, kemudian diurutkan dengan cara upheap.
o Bila menghapus heap dengan mengambil kunci pada parent di level 1 kemudian
digantikan posisi kunci terakhir, selanjutnya disort kembali metode downheap.

21
 Array :

Left_child(i) = 2i
Right_child = 2i+1
Parent = j div 2

Metode Upheap:
 Bandingkan kunci terakhir dengan parentnya apabila parent < kunci maka lakukan
pertukaran.
 Ulangi langkah 1 dengan membandingkan dengan parent selanjutnya sampai posisi
parent di level 1 selesai dibandingkan.

Metode Downheap:
 Bandingkan parent dengan left child dan right child apabila parent < left child atau
right child maka lakukan pertukaran.
 Ulangi langkah 1 dengan membandingkan dengan left child dan right child pada
posisi level di bawahnya sampai posisi di level terakhir selesai dibandingkan.

7. Merge Sort
Pola Divide and Conquer
Beberapa algoritma mengimplementasikan konsep rekursi untuk menyelesaikan
permasalahan. Permasalahan utama kemudian dipecah menjadi sub-masalah, kemudian
solusi dari sub-masalah akan membimbing menuju solusi permasalahan utama.
Pada setiap tingkatan rekursi ini, pola tersebut terdiri atas 3 langkah:
3. Divide
Memilah masalah menjadi sub masalah

4. Conquer
Selesaikan sub masalah tersebut secara rekursif. Jika sub-masalah tersebut cukup
ringkas dan sederhana, pendekatan penyelesaian secara langsung akan lebih
efektif.

5. Kombinasi
Mengkombinasikan solusi dari sub-masalah, yang akan membimbing menuju
penyelesaian atas permasalahan utama.

Memahami Merge Sort

Seperti yang telah dijelaskan sebelumnya, Merge Sort menggunakan pola divide and
conquer. Dengan hal ini deskripsi dari algoritma dirumuskan dalam 3 langkah berpola divide-
and-conquer. Berikut ini langkah kerja dari Merge Sort.

22
 1. Divide
Memilah elemen-elemen dari rangkaian data menjadi dua bagian.
2. Conquer
Conquer setiap bagian dengan memanggil prosedur merge sort secara rekursif.
3. Kombinasi
Mengkombinasikan dua bagian tersebut secara rekursif untuk mendapatkan
rangkaian data berurutan.

Proses rekursi berhenti jika mencapai elemen dasar. Hal ini terjadi bilamana bagian
yang akan diurutkan menyisakan tepat satu elemen. Sisa pengurutan satu elemen tersebut
menandakan bahwa bagian tersebut telah terurut sesuai rangkaian.

Algoritma Merge Sort

void mergeSort(Object array[], int startIdx, int endIdx) {
if (array.length != 1) {
//Membagi rangkaian data, rightArr dan leftArr
mergeSort(leftArr, startIdx, midIdx);
mergeSort(rightArr, midIdx+1, endIdx);
combine(leftArr, rightArr);
}
}

Sebuah contoh
Rangkaian data:

Membagi rangkaian menjadi dua bagian: LeftArr dan RightArr

Membagi LeftArr menjadi dua bagian:

LeftArr RightArr

Mengkombinasikan

Membagi RightArr menjadi dua bagian:

LeftArr RightArr
5 6

Mengkombinasikan

Mengkombinasikan LeftArr dan RightArr

23
Latihan Soal
1. Insertion Sort

Perhatikan kode di bawah ini!

a) Apa yang dilakukan pada program di atas?

b) Lakukan untuk pengurutan sebaliknya!
c) Apakah fungsi tampung?
d) Buatlah program agar user bisa menginputkan data secara dinamis, baik untuk
ascending maupun descending!
e) Tambahkan kode agar user dapat melihat proses pengurutan data!

24
2. Selection Sort

Perhatikan kode di bawah ini!

a) Apa yang dilakukan pada program di atas?

b) Lakukan untuk pengurutan sebaliknya!
c) Apakah fungsi pos?
d) Buatlah program agar user bisa menginputkan data secara dinamis, baik untuk
ascending maupun descending!
e) Tambahkan kode agar user dapat melihat proses pengurutan data!

3. Merge Sort
Gunakan implementasi merge sort berikut ini terhadap serangkaian data integer.

25
class MergeSort {
static void mergeSort(int array[], int startIdx, int endIdx)
{
if(startIdx == _____)
{
return;
}
int length = endIdx-startIdx+1;
int mid = _____;
mergeSort(array, _____, mid);
mergeSort(array, _____, endIdx);
int working[] = new int[length];
for(int i = 0; i < length; i++)
{
working[i] = array[startIdx+i];
}
int m1 = 0;
int m2 = mid-startIdx+1;
for(int i = 0; i < length; i++)
{
if(m2 <= endIdx-startIdx)
{
if(m1 <= mid-startIdx)
{
if(working[m1] > working[m2])
{
array[i+startIdx] = working[m2++];
}
else
{
array[i+startIdx] = _____;
}
}
else
{
array[i+startIdx] = _____;
}
}
else
{
array[_____] = working[m1++];
}
}
}
public static void main(String args[])
{
int numArr[] = new int[args.length];
for (int i = 0; i < args.length; i++)
{
numArr[i] = Integer.parseInt(args[i]);
}
mergeSort(numArr, 0, numArr.length-1);
for (int i = 0; i < numArr.length; i++)

26
 {
System.out.println(numArr[i]);
}
}
}

4. Quick Sort
Gunakan implementasi merge sort berikut ini terhadap serangkaian data integer.

class QuickSort {
static void quickSort(int array[], int startIdx, int endIdx)
{
//startIdx adalah index bawah
//endIdx adalah index atas
//dari array yang akan diurutkan
int i=startIdx, j=endIdx, h;
//pilih elemen pertama sebagai pivot
int pivot=array[_____];

//memilih
do
{
while (array[i] _____pivot)
{
i++;
}
while (array[j]> _____)
{
j--;
}
if (i<=j)
{
h=_____;
array[i]= _____;
array[j]= _____;
i++;
j--;
}
}while (i<=j);

//rekursi
if (startIdx<j)
{
quickSort(array, _____, j);
}
if (i<endIdx)
{
quickSort(array, _____, endIdx);
}
}
public static void main(String args[])
{
int numArr[] = new int[args.length];
for (int i = 0; i < args.length; i++)

27
 {
numArr[i] = Integer.parseInt(args[i]);
}
quickSort(numArr, 0, numArr.length-1);
for (int i = 0; i < numArr.length; i++)
{
System.out.println(numArr[i]);
}
}
}

28
 Daftar Pustaka

 DF Alfatwa, ER Syah P, FM Ahsan, “Implementasi Algoritma Radix Sort dalam Berbagai Kasus
Bilangan Dibandingkan Algoritma Pengurutan yang lain”. Bandung. 2005.
 Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Introduction To Algorithms, McGraw-
Hill. 1990.
 Handbook UI, Algoritma - algoritma pengurutan internal
http://ranau.cs.ui.ac.id/sda/archive/1998/handout/handout24.html
 Wikipedia, (2007). Wikipedia, the free encyclopedia. http://en.wikipedia.org/wiki/Counting_Sort
 Wikipedia, (2007). Wikipedia, the free encyclopedia.
http://en.wikipedia.org/wiki/Sorting_Algorithm
 Wikipedia, (2007). Wikipedia, the free encyclopedia. http://en.wikipedia.org/wiki/Radix_Sort
 http://202.91.15.14/upload/files/6917_02-Sorting.pdf
 http://lecturer.eepis-its.edu/~arna/Modul_ASD/8.5%20Quick-Sort.pdf
 http://icomit.wordpress.com/2010/12/21/1jam-mahir-selection-sort-menggunakan-java/
 http://poss.ipb.ac.id/files/JENI-Intro2-Bab06-Algoritma%20Sorting.pdf

29