RESUME ALGORITMA MERGE SORT DAN REKURENS

(1)

RESUME

ALGORITMA MERGE SORT

DAN REKURENS

SRY WAHYUNI

H12111292

(2)

Algoritma Merge Sort dan Rekurens

Page 2

ALGORITMA 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 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 membutuhkan 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, masing-masing bagian berukuran n/2 elemen.

b) CONQUER: secara rekursif, terapkan algoritma D-and-C pada masing-masing 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:

Untuk menyederhanakan perhitungan kompleksitas waktu MergeSort, kita membuat asumsi ukuran tabel adalah perpangkatan dari 2, yaitu n= dengan k adalah bilangan bulat positif . Kompleksitas waktu dihitung dari jumlah perbandingan dengan elemen-elemen tabel.

(3)

Page 3

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):

{

(₎

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

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.

(4)

Page 4

Merge(A, p, q, r)

Pernyataan ini waktu komputasinya adalah O(n). Bagian ini merupakan proses combine, yaitu data digabungkan kembali.

Contoh

Penyelesaian dengan dengan Divide and Conquer. Misalkan tabel A berisi elemen-elemen sebagai berikut: A= 4 12 23 9 21 1 35 2 24

Algoritma MinMaks:

1. Untuk kasus n = 1 atau n = 2,

SOLVE: Jika n = 1, maka min = maks = An.

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 masing-masing 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.

(5)

Page 5

Tinjau kembali soal di atas

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

4 12 23 9 21 1 35 2 24

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

4 12 23 9 21 1 35 2 24

min = 4 min = 9 min = 1 min = 35 min = 2 maks = 12 maks = 23 maks = 21 maks =35 maks = 24

4 12 23 9 21 1 35 2 24

min = 4 min = 1 min = 2

maks = 23 maks = 21 maks = 35

4 12 23 9 21 1 35 2 24 min = 4 min = 1 maks = 23 maks = 35 4 12 23 9 21 1 5 2 24 min = 1 maks = 35

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

Merge Sort : contoh lain

Pertama, data dibagi 2 bagian, selanjutnya tiap bagian dibagi lagi menjadi dua bagian, demikian selanjutnya hingga data tidak dapat dibagi lagi. Tahap ini merupakan divide.

(6)

Page 6

Setelah dibagi hingga potongan terkecil, data tesebut diurutkan kembali.

(7)

Page 7

Setelah data diurutkan kembali, maka tahap terakhir adalah data tersebut disatukan/dikombain.

Implementasi Merge Sort : #include <stdio.h>

#include <stdlib.h> #include <string.h>

void printv(char* in, int *v, int n) { printf("%s", in); int i = 0; for (; i < n; ++i) printf("%d ", v[i]); printf("\n"); }

void merge(int *v, int p, int q, int r) { int i = p;

int j = q + 1;

int *tmp = (int*)malloc((r - p + 1) * sizeof(int)); int k = 0;

while ((i <= q) && (j <= r)) { if (v[i] < v[j]) tmp[k++] = v[i++]; else tmp[k++] = v[j++]; } while (i <= q) tmp[k++] = v[i++]; while (j <= r)

(8)

Page 8

tmp[k++] = v[j++];

memcpy(v + p, tmp, (r - p + 1) * sizeof(int)); free(tmp);

}

void mergeS(int *v, int p, int r) { if (p < r) { int q = (p + r) / 2; mergeS(v, p, q); mergeS(v, q + 1, r); merge(v, p, q, r); } }

int main(int argc, char *argv[]) { int n = 10; int v[] = {9, 8, 7, 6, 5, 5, 4, 3, 2, 1}; printv("V: ", v, n); mergeS(v, 0, n - 1); printv("V: ", v, n); return 0; } Output: RECURRENCE

Recurrence adalah fungsi yang memanggil dirinya sendiri. Rekurensi adalah suatu persamaan atau pertidaksamaan yang menguraikan fungsi dalam suku-suku nilai input yang lebih kecil. Pada bagian ini ada tiga metode untuk menyelesaikan rekurensi, yaitu untuk mendapatkan batas asymptotic

"



"

atau

"O

"

pada solusi. Ketiga metode adalah metode iterasi, substitusi, metode

master.

Menyelesaikan fungsi recurrence, terdapat 3 metode, yakni: 1. Metode substitusi

o Pertama-tama dibuat suatu “guess” dari bentuk solusinya.

o Gunakan induksi matematika untuk membuktikan bahwa guess itu benar.

o Metode ini dapat digunakan untuk menentukan baik batas atas maupun batas bawah suatu rekurensi.

(9)

Page 9

Contoh:

Tentukan batas atas dari T(n) = 2(T(n/2)) + n Jawab:

 Pertama, dibuat “guess” dari solusinya adalah T(n) = O(n lg n)

 Kedua, dibuktikan dengan induksi matematis bahwa solusi di atas benar, yaitu dibuktikan bahwa T(n)  c (nlgn)

– Basis untuk n = 2, T(2) = 2(T(2/2))+ 2 = 4  c (2lg2), dengan c  2

– Anggap solusi diatas berlaku untuk n/2, yaitu T(n/2)  c (n/2) lg (n/2)

– Dibuktikan bahwa solusi diatas berlaku untuk n.

– Substitusikan pertidaksamaan T(n/2)  c (n/2) lg (n/2) ke rekurensi, diperoleh: T(n)  2 (c (n/2) lg (n/2)) + n  cn lg (n/2) + n  cn lg (n) – cn lg 2 + n = cn lg n – cn + n  cn lg n, untuk c  1 (terbukti)

Jadi batas atas dari rekurensi diatas adalah T(n) = O (n lg n)

Pada “guess” kadang-kadang solusinya bisa dengan manipulasi aljabar, karena

belum pernah diketahui solusi yang mirip.

Contoh:

T(n) = 2 T(



n



) + lg n

Jawab:

Misalkan m = lg n



n = 2

m



n = n

1/2

_{= (2}

m

₎

1/2

_{= 2}

m/2

T(2

m

_{) = 2 T(2}

m/2

_{) + m}

Misalkan lagi S(m) = T(2

m

_{), sehingga rekurensinya menjadi S(m) = 2 S(m/2) + m,}

Yang mirip dengan T(n) = T(



n/2



) + n

Jadi solusinya serupa yaitu: S(m) = O(m lg m).

Dengan mengubah kembali dari S(m) ke T(n) diperoleh:

T(n) = T(2

m

_{) = S(m) = O(m lg m)}

= O(lg n (lg lg n))

2. Metode iterasi (pohon rekursif)

Metode iterasi mengkonversi rekurensi ke dalam jumlahan dan kemudian berdasarkan cara untuk bounding summations untuk menyelesaikan rekurensi. Prinsip dari metode iterasi adalah menjabarkan rekurensi sebagai suatu bentuk penjumlahan yang hanya bergantung pada n dan syarat awal.

Contoh:

T(n) = c + T(n/2);

Ganti n dengan n/2 diperoleh: T(n/2) = c + T(n/4) dan T(n/4) = c + T(n/8). Kemudian masukkan ke formula diperoleh:

(10)

Page 10

= c + c + T(n/4) = c + c + T(n/8)

Jika misalkan n = 16, formula di atas dapat dinyatakan: T(16) = c+T(16/2) = c+c+T(16/4) = c+c+c+T(16/8) = c+c+c+c+T(16/16) = c.4 + T(1). Jadi formula di atas misalkan diasumsikan n = 2k T(n) = c+c+....+c+T(1) = c lg(n) + T(1)





(lg( n

))

Contoh pohon rekursif:

Tn = n + T(n)

T(n) = n+2T(n/2)= n log2n, nilai n = (n/2)

n n

n/2 n/2 n

n/4 n/4 n/4 n/4 n

_

nk

n log2n

3. Metode master

Metode master melengkapi batas-batas untuk rekurensi dari bentuk

) ( ) / ( ) (n aT n b f n

T   , dengan

a



1 ,

b



1

, dan

f

(n

)

fungsi yang diketahui; ini

perlu diketahui/dipahami dan dihafal, karena sekali anda melakukan ini penentuan batas asimtotis untuk rekurensi sederhana akan mudah.