Oleh :
Eka Risky Firmansyah
1110091000043
DAFTAR ISI
KATA PENGANTAR
Bismillahirrahmanirrahiim.
Assalamualaikum, wr. wb.
Puji dan syukur penulis panjatkan kepada Allah SWT, shalawat serta salam semoga
senantiasa dilimpahkan kepada Nabi Muhammad SAW, juga untuk para keluarga, sahabat
dan pengikutnya sampai akhir zaman. Karena atas rahmat-Nya, penulis dapat menyelesaikan
karya tulis ini yang berjudul Analisis Perbandingan Algoritma Selection Sort dengan Merge
Sort.
Karya tulis ini dibuat untuk memenuhi tugas Ujian Tengah Semester Genap dari mata
kuliah Analisis Algoritma. Penulis ingin mengucapkan terima kasih kepada Ibu Ria Hari
Gusmita, ST., M.Kom. selaku dosen pengampu, teman-teman dan semua pihak yang
membantu dalam penyelesaian karya tulis ini. Penulis juga menyadari jika karya tulis ini
masih jauh dari kesempurnaan dan terdapat banyak kekurangan. Untuk itu penulis
mengharapkan kritik, koreksi dan saran dari semua pembaca dalam penyempurnaan karya
tulis ini.
Semoga karya tulis ini bermanfaat bagi pembaca, khususnya bagi penulis mengenai
pemahaman analisis algoritma. Penulis menghaturkan permohonan maaf jika masih terdapat
kekurangan dalam karya tulis ini.
Wassalamualaikum, wr. wb.
Penulis
BAB I
PENDAHULUAN
1. Latar Belakang
Dalam pembuatan sebuah aplikasi seringkali kita membutuhkan sebuah algoritma
yang dapat digunakan untuk melakukan pengurutan data, baik data yang berupa
bilangan, karakter dan string. Algoritma yang digunakan tersebut selain harus
menghasilkan data yang benar, juga harus efektif dan efisien. Namun ada hal lain yang
harus dipertimbangkan, misalnya jumlah data yang akan diurutkan. Jika hanya sedikit
data yang akan diurutkan maka perbedaan antar algoritma pengurutan tidak terlalu
berpengaruh, sebaliknya jika terdapat banyak data yang akan diurutkan maka akan
terlihat perbedaan dan keunggulan suatu algoritma, terutama dalam hal kecepatan dan
pemakaian jumlah memori.
Untuk itulah dalam karya tulis ini akan dibahas mengenai dua buah algoritma
pengurutan yaitu algoritma pengurutan seleksi (selection sort) dan algoritma pengurutan
merge (merge sort) dengan analisis dan perbandingan kompleksitasnya.
2. Metode Penulisan
Penulisan karya tulis ini menggunakan metode pustaka terutama dengan sumber atau
referensi dari internet dan analisis dari penulis.
3. Tujuan Penulisan
Penulisan karya tulis ini bertujuan sebagai berikut :
Memenuhi nilai tugas UTS mata kuliah Analisis Algoritma yang diampu oleh ibu
Ria Hari Gusmita, ST., M.Kom.
4. Manfaat Penulisan
Penulis berharap semoga karya tulis ini dapat menambah pemahaman bagi pembaca
dan penulis mengenai analisis algoritma.
BAB II
LANDASAN TEORI
1. Algoritma Pengurutan
Algoritma merupakan urutan aksi-aksi yang dinyatakan dengan jelas dan tidak rancu
untuk memecahkan suatu masalah dalam rentang waktu tertentu. Sedangkan pengurutan
adalah proses pengaturan sekumpulan objek berdasarkan urutan atau susunan tertentu,
dapat berupa pengurutan menaik (ascending) atau menurun (descending).
Contoh, sebuah larik atau array terdiri dari kumpulan bilangan : [3,12,1,50,33,5,28]
efisien. Efektif yaitu tepat sasaran, jelas dan tidak rancu dalam menjalankan aksi-aksinya
serta menghasilkan data yang benar. Efisien yaitu penghematan proses dari sebuah
algoritma, seperti running time dan penggunaan memori.
Metode atau algoritma pengurutan dapat diklasifikasikan menjadi :
1.
2.
pengurutan seleksi (selection sort), pengurutan sisipan (insertion sort), shell (shell sort).
Contoh algoritma pengurutan yang termasuk dalam skema rekursif, yaitu pengurutan
merge (merge sort), pengurutan heap (heap sort) dan pengurutan cepat (quick sort).
Tidak semua algoritma tersebut hanya memiliki satu skema, misalnya algoritma
pengurutan seleksi atau selection sort yang dapat menggunakan skema rekursif, namun
di dalam karya tulis ini selection sort yang dibahas menggunakan skema iteratif.
2. Kompleksitas Algoritma
Efisiensi sebuah algoritma tergantung dari beberapa hal, diantaranya adalah :
Kinerja CPU
Kinerja Memori
Kinerja Disk
Kinerja Jaringan
Algoritma memiliki kompleksitas, kompleksitas merupakan acuan utama utama
untuk mengetahui kecepatan dari sebuah algoritma. Kompleksitas dibagi menjadi tiga,
yaitu :
1. Best case (), yaitu kompleksitas algoritma dimana algoritma tersebut berjalan
dalam kondisi terbaik.
2. Average case (), yaitu kompleksitas algoritma dimana algoritma tersebut berjalan
dalam kondisi sedang, biasanya inputnya secara acak.
3. Worst case (), yaitu kompleksitas algoritma dimana algoritma tersebut berjalan
dalam kondisi terburuk.
3. Growth Function
Kinerja sebuah algoritma biasanya di ukur dengan mengacu pada kondisi
terburuknya, yaitu worst case yang dilambangkan dengan notasi Big O. Notasi Big O
adalah fungsi yang berkaitan dengan kelajuan proses dan kelajuan pertambahan data.
Notasi
Nama
O(1)
Konstan
O(log * n)
Iterasi logaritmik
O(log n)
Logaritmik
O((log n)c)
Polilogaritmik
O(n)
Linear
Contoh Aplikasi
Menentukan apakah suatu bilangan ganjil atau
genap
Algoritma pencarian Hopcraft dan Ullman untuk
himpunan disjoint
Pencarian dalam list terurut dengan Binary
Search Algorithm
Menentukan bilangan prima dengan AKS
primality test
Pencarian dalam list tidak terurut
5
O(n log n)
O(n2)
Linearitmik
Kuadratik
O(nc), c > 1
Poliomial
O(cn)
Eksponensial
O(n!)
Faktorial
O(2cn)
Dobel Eksponensial
4. Notasi Asimptotik
Notasi asimptotik digunakan untuk menentukan kompleksitas suatu algoritma
dengan melihat waktu tempuh (running time) sebuah algoritma. Waktu tempuh algoritma
merupakan fungsi : N R+. Notasi asimptotik memungkinkan untuk membandingkan
suatu algoritma dengan algoritma lainnya. Notasi asimptotik dapat dituliskan dengan
beberapa simbol, yaitu :
Notasi Big O, yaitu notasi asimptotik sebuah fungsi algoritma untuk batas atas.
Notasi Little o, yaitu notasi asimptotik sebuah fungsi algoritma untuk batas atas
namun tidak secara ketat terikat (not asymptotically tight).
Notasi Theta (), yaitu notasi asimptotik sebuah fungsi algoritma untuk batas atas
dan bawah.
Notasi Omega (), yaitu notasi asimptotik sebuah fungsi algoritma untuk batas
bawah, notasi ini berlawanan dengan notasi little-o.
BAB III
PEMBAHASAN
1. Selection Sort
Penjelasan Singkat Selection Sort
Algoritma pengurutan seleksi atau selection sort merupakan kombinasi antara
sorting dan searching. Konsep dari atau selection sort yaitu dengan memilih elemen larik
yang memiliki nilai paling besar atau paling kecil, lalu menempatkannya pada posisi
awal atau akhir elemen larik (array). Lalu elemen terujung pada larik diisolasi. Proses
tersebut dilakukan sebanyak n-1 (jumlah elemen larik dikurang 1).
Algoritma pengurutan seleksi atau selection sort dapat menggunakan skema iteratif
(perulangan biasa) maupun skema rekursif (perulangan dengan memanggil dirinya
sendiri). Namun kali ini kita hanya akan membahas algoritma pengurutan seleksi atau
selection sort yang menggunakan skema iteratif.
Algoritma pengurutan seleksi atau selection sort dibagi menjadi dua, yaitu :
1. Algoritma pengurutan seleksi minimum atau minimum selection sort
Yaitu dengan mencari nilai terkecil dari array dan digunakan sebagai pembanding.
2. Algoritma pengurutan seleksi maksimum atau maximum selection sort
Yaitu dengan mencari nilai terbesar dari array dan digunakan sebagai pembanding.
Pseudocode Minimum Selection Sort
procedure MinSelectionSort(input/output A : Larik, input n : integer)
DEKLARASI :
i, j : integer
imin : integer
temp : integer
ALGORITMA :
for i 1 to n-1 do
imin i
for j i+1 to n do
if A[j] < A[imin]
then imin j
endif
endfor
temp A[i]
A[i] A[imin]
A[imin] temp
endfor
end procedure
Algoritma pengurutan seleksi (selection sort) adalah algoritma yang tidak stabil,
karena urutan beberapa elemen yang sama berbeda antara sebelum dan sesudah
pengurutan. Algoritma ini juga termasuk algoritma pengurutan internal, karena
melakukan sorting di dalam array itu sendiri, dan menyimpan datanya di dalam memori
komputer.
Yang akan dibahas kali ini adalah menggunakan pengurutan seleksi minimum
(minimum selection sort) secara menaik (ascending), yaitu selection sort dengan
menggunakan nilai terkecil di dalam array sebagai pembanding.
Loop Invariant Minimum Selection Sort
Statement
Saat awal algoritma dijalankan, nilai imin berisi indeks elemen terkecil dari larik
A[1...j - 1].
Initialization
Sebelum iterasi atau pass pertama dilakukan, nilai j = i + 1, imin berisi indeks
elemen terkecil dari larik A[i...i] yang merupakan indeks elemen paling pertama
larik A.
Maintenance
Sebelum iterasi ke- jth, imin berisi indeks elemen terkecil dari larik A[i...j - 1].
Kemudian setelah dijalankan, jika A[j] < A[imin] maka imin bernilai sama dengan j
dan menyimpan indeks terkecil larik A[i...j].
Termination
8
Sebelum iterasi ke- (n + 1)th, j = n + 1, imin berisi indeks terkecil dari elemen larik
A[i...n].
19
38
13
21
1. Pass 1
Cari nilai elemen terkecil dari array (larik) A[1...7] dengan membandingkan
antar nilai elemen array, didapatkan elemen terkecil A[4] = 3.
Tukarkan dengan nilai elemen terujung (awal) yaitu A[1]. Lalu elemen A[1]
tersebut sudah terurut.
3
19
38
26
13
21
2. Pass 2
Cari nilai elemen terkecil dari array (larik) A[2...7] dengan membandingkan
antar nilai elemen array, didapatkan elemen terkecil A[5] = 9.
Tukarkan dengan nilai elemen terujung (awal) yaitu A[2]. Lalu elemen A[2]
tersebut sudah terurut.
3
38
26
19
13
21
3. Pass 3
Cari nilai elemen terkecil dari array (larik) A[3...7] dengan membandingkan
antar nilai elemen array, didapatkan elemen terkecil A[6] = 13.
Tukarkan dengan nilai elemen terujung (awal) yaitu A[3]. Lalu elemen A[3]
tersebut sudah terurut.
3
13
26
19
38
21
4. Pass 4
Cari nilai elemen terkecil dari array (larik) A[4...7] dengan membandingkan
antar nilai elemen array, didapatkan elemen terkecil A[5] = 19.
Tukarkan dengan nilai elemen terujung (awal) yaitu A[4]. Lalu elemen A[4]
tersebut sudah terurut.
3
13
19
26
38
21
5. Pass 5
Cari nilai elemen terkecil dari array (larik) A[5...7] dengan membandingkan
antar nilai elemen array, didapatkan elemen terkecil A[7] = 21.
Tukarkan dengan nilai elemen terujung (awal) yaitu A[5]. Lalu elemen A[5]
tersebut sudah terurut.
3
13
19
21
38
26
6. Pass 6 (n-1)
Cari nilai elemen terkecil dari array (larik) A[6...7] dengan membandingkan
antar nilai elemen array, didapatkan elemen terkecil A[7] = 26.
Tukarkan dengan nilai elemen terujung (awal) yaitu A[6]. Lalu elemen A[6]
tersebut sudah terurut.
3
13
19
21
26
38
Elemen yang tersisa yaitu elemen terakhir A[7] = 38. Elemen tersebut tidak perlu
diurutkan karena elemen tersebut berada pada posisi yang sudah terurut. Jadi array atau
larik A sudah terurut. Hasil array A yang sudah terurut yaitu :
3
13
19
21
26
38
Cost
Times
for i 1 to n-1 do
C1
imin i
C2
n-1
for j i+1 to n do
C3
C4
( )
C5
10
( )
endfor
temp L[i]
C6
n-1
C7
C8
0
n-1
n-1
n
endif
L[i] L[imin]
L[imin] temp
endfor
Keterangan :
C3.
C4.
( ) = C4.
C5.
) = C3.
(
) = C5.
( ) + C3.
( ) = C3.
+ C3.(
)
(
o Ketika kondisi best case maka kondisi if salah, ti,j = 0. Kondisi best case terjadi jika
data dalam elemen array sudah terurut. Maka :
( )
( )
Didapatkan notasi asimptotik best case selection sort adalah ( )
o Ketika kondisi worst case maka kondisi if benar, ti,j = 1. Kondisi worst case terjadi
jika data dalam elemen array terurut secara terbalik. Maka :
( )
( )
Didapatkan notasi asimptotik worst case selection sort adalah ( )
o Jadi baik dalam kondisi worst case, average case maupun best case didapatkan
kompleksitas waktu algoritma selection sort yaitu : ( )
11
2. Merge Sort
Penjelasan Singkat Merge Sort
Algoritma merge sort dirancang untuk memenuhi kebutuhan pengurutan jika data
yang diurutkan berjumlah banyak, dan tidak memungkinkan untuk ditampung dalam
memori komputer. Cara kerja atau konsep dari algoritma merge sort adalah
menggunakan metode rekursif dan teknik divide and conquer.
Rekurensi (Reccurence)
Merupakan sebuah fungsi atau prosedur yang digambarkan secara rekursif. Rekursif
adalah proses untuk memanggil dirinya sendiri. Dan fungsi running time-nya dapat
digambarkan oleh recurrence (Rekurensi). Definisi rekursif disusun oleh dua bagian,
yaitu :
1. Basis, yaitu bagian yang berisi kasus yang terdefinisi secara eksplisit dan
berguna untuk menghentikan rekursif (memberikan sebuah nilai yang terdefinisi
pada fungsi rekursif).
2. Rekurens, yaitu bagian yang mendefinisikan objek dalam terminologi dirinya
sendiri.
Misalnya pada proses untuk menghitung faktorial dari n, maka :
Basis :
n!=1
,n=0
Rekurens :
n ! = n x (n - 1) !
,n>0
// Divide step.
// Conquer step.
// Conquer step.
// Conquer step.
PROCEDURE MERGE(A, p, q, r)
12
n1 q p + 1
n2 r q
Create arrays L[1 . . n1 + 1] and R[1 . . n2 + 1]
FOR i 1 TO n1
DO L[i] A[p + i 1]
FOR j 1 TO n2
DO R[j] A[q + j]
L[n1 + 1]
R[n2 + 1]
i 1
j 1
FOR k p TO r
DO IF L[i] R[j]
THEN A[k] L[i]
i i + 1
ELSE A[k] R[j]
j j + 1
Initialization
Maintenance
Misalkan L[i] R[j], maka L[i] adalah elemen terkecil yang tidak di-copy ke array
A. A[pk - 1] adalah k - p elemen terkecil, L[i] adalah (k p + 1)th elemen terkecil.
Kemudian L[i] di-copy ke A[k], A[pk] berisi k p + 1 elemen terkecil. Secara
berulang, nilai k + i membuat perulangan (loop invariant). Jika L[i] > R[j], maka
nilai R[j] di-copy ke array A[k], dan nilai j + 1 agar pengulangan dapat terus
dilakukan.
Termination
Ketika nilai k = r + 1, A[pk - 1] = A[pr] berisi k - p elemen terkecil dalam
keadaan yang terurut. Menghasilkan k - p = r + 1 - p elemen terkecil dalam keadaan
yang terurut. Kedua array L dan R berisi n1 + n2 + 2 = r -p + 3 elemen, dan dua
buah telah di-copy kembali ke array A.
13
24
A[0...3] =
1. MERGESORT(A, 0, 3).
Kemudian diperiksa apakah jika p < r, (0 < 3), jika benar maka dihitung q =
(p + r)/2 = 1.
1.1. MERGESORT(A, 0, 1)
Kemudian diperiksa apakah jika p < r, (0 < 1), jika benar maka dihitung
q = (p + r)/2 = 0.
A[0...1] =
1.1.1. MERGESORT(A, 0, 0)
Kemudian diperiksa apakah jika p < r, (0 < 0), karena salah maka
rekursif pada bagian ini selesai.
1.1.2. MERGESORT(A, 1, 1)
Kemudian diperiksa apakah jika p < r, (1 < 1), karena salah maka
rekursif pada bagian ini selesai.
1.1.3. MERGE(A, 0, 0, 1)
Lalu buat dua buah array bernama L dan R dengan jumlah elemen
o L[1 . . n1 + 1] yaitu L[1...2]
o R[1 . . n2 + 1] yaitu R[1...2]
Perulangan pada :
14
o FOR i 1 TO n1
DO L[i] A[p + i 1]
o nilai L[1] = A[0] = 12.
12
o L[1] =
Perulangan pada :
o FOR j 1 TO n2
DO R[j] A[q + j]
o nilai R[1] = A[1] = 9.
9
o R[1] =
12
Array L =
dan Array R =
12
o A[0...1] =
1.2. MERGESORT(A, 2, 3)
15
Kemudian diperiksa apakah jika p < r, (2 < 3), jika benar maka dihitung
q = (p + r)/2 = 2.
A[2...3] =
1.2.1. MERGESORT(A, 2, 2)
Kemudian diperiksa apakah jika p < r, (2 < 2), karena salah maka
rekursif pada bagian ini selesai.
1.2.2. MERGESORT(A, 3, 3)
Kemudian diperiksa apakah jika p < r, (3 < 3), karena salah maka
rekursif pada bagian ini selesai.
1.2.3. MERGE(A, 2, 2, 3)
Lalu buat dua buah array bernama L dan R dengan jumlah elemen
o L[1 . . n1 + 1] yaitu L[1...2]
o R[1 . . n2 + 1] yaitu R[1...2]
Perulangan pada :
o FOR i 1 TO n1
DO L[i] A[p + i 1]
o nilai L[1] = A[2] = 24.
24
o L[1] =
Perulangan pada :
o FOR j 1 TO n2
DO R[j] A[q + j]
o nilai R[1] = A[3] = 2.
2
o R[1] =
16
24
Array L =
dan Array R =
24
o A[2...3] =
1.3. MERGE(A, 0, 1, 3)
Lalu buat dua buah array bernama L dan R dengan jumlah elemen
o L[1 . . n1 + 1] yaitu L[1...3]
o R[1 . . n2 + 1] yaitu R[1...3]
Perulangan pada :
o FOR i 1 TO n1
DO L[i] A[p + i 1]
o nilai L[1] = A[0] = 9 dan L[2] = A[1] = 12.
9
12
o L[1...2] =
17
Perulangan pada :
o FOR j 1 TO n2
DO R[j] A[q + j]
o nilai R[1] = A[2] = 2 dan R[2] = A[3] = 24.
2
24
o R[1...2] =
12
Array L =
24
dan Array R =
12
24
o A[0...3] =
Jika digambarkan secara sederhana maka proses eksekusi algoritma merge sort
adalah :
18
Array unsorted
12
A[0...3]
24
divide
to sub-array
A[0...1]
12
24
L[]
A[0...1]
A[2...3]
divide
to sub-array L & R
divide
to sub-array L & R
12
24
R[]
L[]
12
2
merge & sort
sub-array L &
R to array A
R[]
24
A[2...3]
A[0...3]
12
24
12
24
A[0...3] =
Analisis dan Running Time Merge Sort
Merge sort selalu membagi setiap array menjadi dua sub-array hingga mencapai
basis, sehingga kompleksitas dari algoritma merge sort, berlaku untuk semua kasus
(Worst Case = Best Case = Average Case).
Untuk memudahkan, kita anggap jumlah elemen array (n) adalah kelipatan 2, jadi
setiap dilakukan divide (pemecahan menjadi dua sub-array), kedua sub-array akan
berukuran n/2.
Rekurens : untuk n > 1, maka akan dilakukan langkah-langkah merge sort, yaitu :
o Divide : Hitung nilai q yang merupakan rata-rata dari p + r, yang bernilai (1).
o Conquer : Secara rekursif menyelesaikan 2 sub-array, setiap sub-array
berukuran n/2, maka bernilai 2T(n/2).
19
( )
{
( )
( )
o Di dapatkan tinggi pohon rekursif adalah log n, dan memiliki sebanyak log n +
1 level. Setiap level bernilai cn, sehingga cn log n + cn.
o Koefisien c tidak perlu di masukkan, sehingga kompleksitas waktunya menjadi
( )
20
2. Merge sort memiliki kompleksitas waktu untuk kondisi best case, average case
maupun worst case dengan : ( )
Jika dibandingkan dari kompleksitas waktu kedua algoritma tersebut maka algoritma
yang running time-nya lebih cepat adalah algoritma merge sort. Baik dalam keadaan
best case, average case maupun worst case. Merge sort memiliki running time yang
lebih cepat dibandingkan selection sort, karena nilai n log n lebih kecil dari n2.
Untuk jumlah data atau elemen array yang sedikit, perbedaan running time selection
sort dan merge sort tidak terlalu terlihat, bisa saja lebih cepat selection sort atau merge
sort. Hal ini dapat dipengaruhi oleh kemampuan komputer, jumlah memori dan faktor
lain. Namun jika jumlah data atau elemen array yang sangat banyak, perbedaan running
time selection sort dan merge sort akan sangat terlihat, semakin banyak data yang akan
diurutkan, semakin terlihat perbedaan running time-nya.
21
BAB IV
KESIMPULAN & SARAN
1. Kesimpulan
Hasil analisis perbandingan selection sort dan merge sort menunjukkan bahwa
running time merge sort lebih cepat. Hal ini akan terlihat jika jumlah data yang akan
diurutkan berjumlah banyak, semakin banyak data semakin terlihat perbedaan kecepatan
algoritma. Sedangkan jika data berjumlah sedikit maka perbedaan antara selection sort
dan merge sort tidak begitu siginifikan.
Perlu dipertimbangkan juga faktor lain yang mempengaruhi kecepatan eksekusi
sebuah algoritma selain kompleksitas waktu dan jumlah data, yaitu faktor kemampuan
komputer, jumlah memori dan lain-lain. Selain itu pertimbangan dari penggunaan sebuah
algoritma tidak hanya di lihat dari running time-nya, tetapi dari kebutuhan. Misalnya kita
membutuhkan algoritma untuk mengurutkan jumlah data yang sedikit (kurang dari 100
elemen), maka kita dapat menggunakan selection sort daripada merge sort karena
perbedaan kecepatan yang tidak signifikan.
2. Saran
Penulis menyarankan untuk penulisan karya tulis selanjutnya agar algoritma
pengurutan yang dibahas lebih banyak lagi disertai dengan simulasi dan analisis, serta
diberikan contoh program atau program simulasi step-by-step untuk memperjelas materi
pembahasan.
22
DAFTAR PUSTAKA
diakses
24