RESUME ALGORITMA DAN STRUKTUR DATA LANJUT

ALGORITMA MERGE SORT, DIVIDE AND CONQUER

Oleh :
SYAMSUL BACHRI
0093-01-39-2013
MM-9

MAGISTER MANAJEMEN
KONSENTRASI SISTEM INFORMASI
PASCA SARJANAUNIVERSITAS MUSLIM INDONESIA
2014/2015

ALGORITMA MERGE SORT

MERGE SORT
Merge sort merupakan algoritma pengurutan dalam ilmu komputer yang
dirancang untuk memenuhi kebutuhan pengurutan atas suatu rangkaian
data yang tidak memungkinkan untuk ditampung dalam memori komputer
karena jumlahnya yang terlalu besar. Algoritma ini ditemukan oleh John von
Neumann pada tahun 1945. (id.wikipedia.org)
Divide, conquer, dan combine
Algoritma pengurutan data merge sort dilakukan dengan menggunakan cara
divide and conquer yaitu dengan memecah kemudian menyelesaikan setiap
bagian kemudian menggabungkannya kembali. Pertama data dipecah
menjadi 2 bagian dimana bagian pertama merupakan setengah (jika data
genap) atau setengah minus satu (jika data ganjil) dari seluruh data,
kemudian dilakukan pemecahan kembali untuk masing-masing blok sampai
hanya terdiri dari satu data tiap blok. Setelah itu digabungkan kembali
dengan membandingkan pada blok yang sama apakah data pertama lebih
besar daripada data ke-tengah+1, jika ya maka data ke-tengah+1 dipindah
sebagai data pertama, kemudian data ke-pertama sampai ke-tengah digeser
menjadi data ke-dua sampai ke-tengah+1, demikian seterusnya sampai
menjadi satu blok utuh seperti awalnya. Sehingga metode merge sort
merupakan
metode
yang
memutuhkan
fungsi
rekursi
untuk
penyelesaiannya.
Algoritma Merge Sort ialah algoritma pengurutan yang berdasarkan pada
strategi divide and conquer. Algoritma Merge Sort dilakukan dengan
memenuhi kondisi sebagai berikut :
1. Untuk kasus n=1, maka table a sudah terurut sendirinya (langkah solve)
2. Untuk kasus n>1, maka :
a. DIVIDE: bagi table a menjadi dua bagian, bagian kiri dan bagian kanan,
masingmasing bagian berukuran n/2 elemen.
b. CONQUER: secara rekursif, terapkan algoritma D-and-C pada masingmasing bagian.
c. MERGE: gabung hasil pengurutan kedua bagian sehingga diperoleh
table a yang terurut.
Dengan menerapkan kedua aturan diatas secara terus menerus maka
nantinya akan didapatkan list yang terurut. Pseudo Code untuk algoritma
MergeSort adalah sebagai berikut:

Prosedur MergeSort (array int a,

int i, int )
Deklarasi :
k: integer
Algoritma :
If i<j then
K (i+j) div 2
MergeSort(a,i,k)
MergeSort(a,k+1,j)
Merge(a,i,k,j)

procedure Merge(input/outputA : TabelInt, input kiri,tengah,kanan :

integer)
{ Menggabung tabel A[kiri..tengah] dan tabel A[tengah+1..kanan]
menjadi tabel A[kiri..kanan] yang terurut menaik.
Masukan: A[kiri..tengah] dan tabel A[tengah+1..kanan] yang sudah
terurut menaik.
Keluaran: A[kiri..kanan] yang terurut menaik. }
Deklarasi
B : TabelInt
i, kidal1, kidal2 : integer
Algoritma:
kidal1kiri { A[kiri .. tengah] }
kidal2tengah + 1 { A[tengah+1 .. kanan] }
ikiri
while (kidal1 tengah) and (kidal2 kanan) do
if Akidal1 Akidal2 then
BiAkidal1
kidal1kidal1 + 1
else
BiAkidal2
kidal2kidal2 + 1
endif
ii + 1
endwhile
{ kidal1 > tengah or kidal2 > kanan }
{ salin sisa A bagian kiri ke B, jika ada }
while (kidal1 tengah) do
BiAkidal1
kidal1kidal1 + 1
ii + 1
endwhile
{ kidal1 > tengah }
{ salin sisa A bagian kanan ke B, jika ada }
while (kidal2 kanan) do
BiAkidal2
kidal2kidal2 + 1
ii + 1
endwhile
{ kidal2 > kanan }
{ salin kembali elemen-elemen tabel B ke A }
for ikiri to kanan do
AiBi
endfor

Untuk menyederhanakan perhitungan kompleksitas waktu MergeSort, kita

membuat asumsi ukuran tabel adalah perpangkatan dari 2, yaitu n=2K
dengan k adalah bilangan bulat positif2 . Kompleksitas waktu dihitung dari
jumlah perbandingan dengan elemenelemen tabel.

T(n) = jumlah perbandingan pada pengurutan dua buah subtabel + jumlah

perbandingan pada prosedur Merge.
Kompleksitas prosedur Merge adalah t(n) = cn = O(n), sehingga
kompleksitas algoritma Merge Sort menjadi (dalam bentuk relasi rekurens):

T (n)

a , n=1
n
2T
+ cn ,n> 1
2

()

dalam hal ini,a dan c adalah konstanta.

Penyelesaian persamaan rekurens:
T(n) =T(n/2)+cn
= 2(2T(n/4) + cn/2) + cn
= 4T(n/4) + 2cn
= 4(2T(n/8) + cn/4) + 2 cn
= ...
= 2k T(n/2k)+kcn
Berhenti jika ukuran tabel terkecil, n = 1:
n/2k = 1 k = 2log n
sehingga
T(n) = nT(1) + cn 2log n
= na + cn 2log n
= O(n 2log n)
Kesimpulan
Kompleksitas dari algoritma Merge sort adalah O(n 2log n) baik worst case
maupun best case.
Berapapun datanya (n>1), walaupun datanya sudah urut, akan tetap
dilakukan prosedur MergeSort (pembagian data menjadi n/2) dan Merge
(pembandingan dan penggabungan data).
Divide and Conquer merupakan algoritma yang berprinsip memecah-mecah
permasalahan yang terlalu besar menjadi beberapa bagian kecil sehingga
lebih mudah untuk diselesaikan. Langkah-langkah umum algoritma Divide
and Conquer :

Divide : Membagi masalah menjadi beberapa upa-masalah yang

memiliki kemiripan dengan masalah semula namun berukuran lebih
kecil ( idealnya berukuran hampir sama).
Conquer : Memecahkan ( menyelesaikan ) masing-masing upa-masalah
( secara rekursif).
Combine : Menggabungkan solusi masing-masing upa-masalah
sehingga membentuk solusi masalah semula.

Merge sort pseucode

Merge-Sort(A, p, r):
if p < r then
q(p+r)/2
Merge-Sort(A, p, q)
Merge-Sort(A, q+1, r)
Merge(A, p, q, r)
if p < r then
Bagian ini di proses sebanyak O(1).
q(p+r)/2
Pernyataan ini akan dieksekusi sebanyak n/2. Karena data dibagi dua.
Merge-Sort(A, p, q)
Merge-Sort(A, q+1, r)
Pernyataan ini waktu komputasinya adalah T(n/2). Pada bagian ini
merupakan proses divide yaitu data dipecah (dibagi-bagi) hingga potongan
terkecil.
Merge(A, p, q, r)
Pernyataan ini waktu komputasinya adalah O(n). Bagian ini merupakan
proses combine, yaitu data digabungkan kembali.
Contoh kasus :
Menentukan nilai minimum dan maksimum urutan bilangan.
Penyelesaian dengan dengan Divide and Conquer.
Misalkan tabel A berisi elemen-elemen sebagai berikut:
A= 4 12 23 9 21 1 35 2 24
Ide dasar algoritma secara Divide and Conquer:

12

23

21

35

24

35

24

1
35
min = 1
maks = 35

24

24

DIVIDE
4

12

23
9
21
1
SOLVE : tentukan min &
maks pada tiap bagian

4
12
min = 4
maks = 23

23

21

4
12
min = 1
maks = 35

23

COMBINE
9
21

35

Algoritma MinMaks:
1. Untuk kasus n = 1 atau n = 2,
SOLVE: Jika n = 1, maka min = maks = A n. Jika n = 2, maka bandingkan
kedua elemen untuk menentukan min dan maks.
2. Untuk kasus n > 2,
a. DIVIDE: Bagi dua tabel A secara rekursif menjadi dua bagian yang
berukuran sama, yaitu bagian kiri dan bagian kanan.
b. CONQUER: Terapkan algoritma Divide and Conquer untuk masingmasing bagian, dalam hal ini min dan maks dari tabel bagian kiri
dinyatakan dalam peubah min1 dan maks1, dan min dan maks dari
tabel bagian kanan dinyatakan dalam peubah min2 dan maks2.
c. COMBINE: Bandingkan min1 dengan min2 untuk menentukan min
tabel A. Bandingkan maks1 dengan maks2 untuk menentukan maks
tabel A

DIVIDE dan CONQUER: Bagi tabel menjadi dua bagian sampai berukuran 1
atau 2 elemen:
4

12

23

21

35

24

12

23

21

35

24

12

23

21

35

24

SOLVE dan COMBINE: Tentukan min dan maks masing-masing bagian tabel,
lalu gabung:
4

12

23

21

35

24

min=4
maks=12

min=9
maks=23 maks=21

min=1
min=35
maks=35 maks=24

23

35

12

min = 4
maks=23
4

12

12

24

min = 1
min = 2
maks = 21 maks=35
23

min = 4
maks = 23
4

21

21

35

24

35

24

min = 1
maks = 35
23

21

min = 1
maks = 35
Jadi, nilai minimum tabel = 1 dan nilai maksimum = 35.

min=2

Contoh D&C : Merge Sort

Merge sort, seperti namanya, merupakan algoritma yang dirancang untuk
melakukan pengurutan terhadap sekumpulan bilangan. Ide utama dari
merge sort sama dengan algoritma perhitungan total yang telah kita lakukan
sebelumnya, yaitu membagi-bagikan keseluruhan list menjadi komponen
kecil,
dan
kemudian
mengurutkan
komponen
tersebut
dan
menggabungkannya kembali menjadi sebuah list besar.
Berikut adalah merge sort yang diimplementasikan dalam bahasa python:
def merge_sort(lst):
if len(lst) <= 1:
return lst
mid = len(lst) // 2
left = merge_sort(lst[:mid])
right = merge_sort(lst[mid:])
return merge(left, right)
def merge(left, right):
result = []
while len(left) > 0 or len(right) > 0:
if len(left) > 0 and len(right) > 0:
if left[0] <= right[0]:
result.append(left.pop(0))
else:
result.append(right.pop(0))
elif len(left) > 0:
result.append(left.pop(0))
elif len(right) > 0:

result.append(right.pop(0))

Dari kode di atas terlihat bahwa merge sort memiliki dua bagian, yang dituliskan
dalam dua buah fungsi: merge dan merge_sort. Fungsi merge_sort memiliki logika
dan cara kerja yang sama dengan fungsi penjumlahan total yang kita bangun
sebelumnya, dengan perbedaan pada bagian yang melakukan penggabungan list
(return merge(left, right)).
Penggabungan list sendiri dilakukan dengan cukup sederhana dan gamblang, yaitu
hanya membandingkan elemen-elemen dari dua buah list yang dikirimkan satu per
satu, untuk kemudian disimpan ke dalam variabel result secara terurut. Untuk lebih
jelasnya, mari kita coba bedah algoritma pada fungsi merge, langkah demi langkah.
Misalkan kita memanggil fungsi merge seperti berikut:
left = [3, 5]
right = [1, 4]
merge(left, right)

Jika kita mengikuti langkah demi langkah pada kode, maka pada setiap
iterasi while kita akan mendapatkan nilai masing-masing variabel sebagai
berikut:
# Awal fungsi
left = [3, 5]
right = [1, 4]
result = []
# Iterasi 1
left = [3, 5]
right = [4]
result = [1]
# Iterasi 2
left = [5]
right = [4]
result = [1, 3]
# Iterasi 3
left = [5]
right = []
result = [1, 3, 4]
# Iterasi 4
left = []
right = []
result = [1, 3, 4, 5]

Penggabungan seperti di atas dilakukan pada setiap submasalah yang telah

dipecah oleh merge_sort, sampai kita mendapatkan sebuah list dengan
ukuran yang sama pada list awal. Untuk mempermudah pengertian, gambar
di bawah menunjukkan proses pemecahan dan penggabungan kembali dari
merge sort:

Langkah Kerja Merge Sort

Proses divide terjadi ketika kotak dan panah berwarna merah, sementara
conquer dan combine terjadi ketika kotak dan panah diberi warna biru.
Proses conquer merupakan proses di mana kita mengurutkan elemen dalam
list, dan combine adalah ketika kita menggabungkan hasil urutan dari list
tersebut.

TEKNIK ITERATIF & REKURSIF

TEKNIK ITERATIF
Teknik Iteratif merupakan suatu teknik pembuatan algoritma dengan
pemanggilanprocedure beberapa kali atau hingga suatu kondisi tertentu
terpenuhi
Contoh :
Teknik Iteratif pada algoritma untuk menghitung faktorial dari bilangan bulat
positif n, adalah sebagai berikut :
Function FAK (n : integer) : integer
FAK=1
For i = 1 TO n
FAK = FAK * i
NEXT i
END FAK

Gambaran jalannya proses algoritma tersebut adalah sebagai berikut :

Misal n = 5, maka : FAK = 1, kemudian

Contoh :
BARISAN BILANGAN FIBBONACI 1, 1, 2, 3, 5, 8, 13, 21, . . .
Teknik Iteratif pada algoritma untuk menentukan suku ke-n dari barisan
bilangan Fibbonaci, adalah sebagai berikut :
1.
2.
3.

Set x, y, n, i, f : integer
x1;y1
If n 2 then
begin
4.
for i 3 to n do
begin
5.
Fx+y
6.
xy
7.
yF
end
else
8.
Fx
9.
Write(F)
End
Gambaran jalannya proses algoritma tersebut adalah sebagai berikut :
Misal n = 5, maka :
x=1, y=1, kemudian

TEKNIK REKURSIF
Teknik Rekursif merupakan salah satu cara pembuatan algoritma dengan
pemanggilan procedure atau function yang sama
Contoh :
Teknik Rekursif pada algoritma untuk menghitung faktorial dari bilangan
bulat positif n, adalah sebagai berikut :
Function FAK (n : integer) : integer
1. If n := 0 then FAK := 1
2. Else FAK := n * FAK(n-1)
Gambaran jalannya proses algoritma tersebut adalah sebagai berikut :
Misal n = 5, maka :

Contoh :
BARISAN BILANGAN FIBBONACI 1, 1, 2, 3, 5, 8, 13, 21, . . .
Teknik Rekursif pada algoritma untuk menentukan suku ke-n dari barisan bilangan
Fibbonaci, adalah sebagai berikut :
Procedure F(n : integer) : integer
1.
If n 2 then F(n) = 1
Else F(n) = F(n-1) + F(n-2)
Endif
End
Gambaran jalannya proses algoritma tersebut adalah sebagai berikut :
Misal n = 5, maka :

Perbedaan Antara Teknik Iteratif dan Rekursif :

ITERATIF

REKURSIF

Tidak ada variabel lokal baru

Program tidak sederhana

Ada variabel lokal baru

Program
menjadi
sederhana

lebih