Tugas Resume Algorithm

MERGE SORT REVISITED

Oleh :

NAMA NIM

: MONIKA S. RAHAYU : H12111011

FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM UNIVERSITAS HASANUDDIN MAKASSAR 2012

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. Prinsip utama yang diimplementasikan pada algoritma merge-sort seringkali disebut sebagai pecah-belah dan taklukkan ( divide and conquer). Cara kerja algoritma merge sort adalah membagi larik data yang diberikan menjadi dua bagian yang lebih kecil. Kedua larik yang baru tersebut kemudian akan diurutkan secara terpisah. Setelah kedua buah list tersusun, maka akan dibentuk larik baru sebagai hasil penggabungan dari dua buah larik sebelumnya. Menurut keefektifannya, alogaritma ini bekerja dengan tingkat keefektifan O(nlog(n)). Pada algoritma Divide and Conquer ini memiliki tiga proses utama yaitu : Divide : membagi masalah menjadi beberapa sub-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 : mengabungkan solusi masing-masing upa masalah sehingga membentuk solusi masalah semula.

Contoh

[10, 4, 6, 3] [10, 4] [10] [4 , 10] [4] [6] [3, 6] [3, 4, 6, 10] [6, 3] [3] [8]

[ 8, 2, 5, 7 ] [8, 2] [2] [2, 8] [2, 5, 7, 8 ] [5] [5, 7] [5, 7] [7]

[ 2, 3, 4, 5, 6, 7, 8, 10]

: Devide : Conquer : Combine

KOMPLEKSITAS WAKTU Asumsi : T(n) = jumlah perbandingan pada pengurutan 2 buah table + jumlah perbandingan pada procedure merge. ( )

Proses : ( ) ( ( ( ) ( ) ( ) ) ) ( ) ( )

Berhenti jika ukuran tabel terkecil ,n =1: 2 log n Sehingga T(n)=nT(1)+cn 2log n = na +cn 2log n = O(n 2log n)

IMPLEMENTASI MERGE SORT program MergeSort; uses crt; type mrg = array [1..100] of integer; var mrge1,mrge2 : mrg; x,m : integer; procedure merge(Left:mrg; pjgL:integer; Right : mrg; pjgR:integer; var ArrMerge : mrg); {IS : Menerima array left dan array right untuk dibandingkan dan disusun kembali ke array merge} {FS : Hasil penggabungan akan dikembalikan melalui variabel output ArrMerge} var i,j,k,m,panjang: integer; hasil : mrg; begin i:=1; j:=1; k:=1; panjang:=pjgL+pjgR; {membandingkan 2 array Left dan Right hingga panjang salah satu array mencapai 0 } while ((pjgL>0) and (pjgR>0)) do begin {jika elemen pertama array Left lebih kecil dari elemen array Right maka elemen pertama pada array hasil diisi oleh elemen pertama array Left} if(Left[i]<= Right[j]) then

begin hasil[k]:=Left[i]; i:=i+1; k:=k+1; pjgL:=pjgL-1; end {jika elemen pertama array Left lebih besar dari elemen array Right maka elemen pertama pada array hasil diisi oleh elemen pertama array Right} else begin hasil[k]:=Right[j]; j:=j+1; k:=k+1; pjgR:=pjgR-1; end; end; {Jika array Left belum kosong dan array Right sudah kosong, maka sisa dari Left dimasukkan ke array Hasil} while (pjgL>0) do begin hasil[k]:=Left[i]; i:=i+1; k:=k+1; pjgL:=pjgL-1; end;

{Jika array Left belum kosong dan array Right sudah kosong, maka sisa dari Left dimasukkan ke array Hasil} while (pjgR>0) do begin hasil[k]:=Right[j]; j:=j+1; k:=k+1; pjgR:=pjgR-1; end; {Mengembalikan nilai ke variabel output ArrMerge} ArrMerge:=hasil; for m:= 1 to panjang do writeln('Array Merge ke-',m,' : ',hasil[m]); end;

procedure msort(pjg:integer;A : mrg;var ArrHasil : mrg); {IS : Menerima Array yang akan dibagi menjadi 2 array yaitu array Left dan array Right} {FS : Mengembalikan array yg terurut melalui variabel output ArrHasil} var middle,i,pjgLeft,pjgRight : integer; ArrLeft,ArrRight : mrg; begin if pjg <= 1 then ArrHasil := A else

begin middle := pjg div 2; for i:=1 to middle do ArrLeft[i]:=A[i];

for i:=(middle+1) to pjg do ArrRight[i-middle]:=A[i]; pjgLeft := pjg div 2; pjgRight := (pjg+1) div 2; for m:= 1 to pjgLeft do writeln('Array Left ke-',m,' : ',ArrLeft[m]); for m:= 1 to pjgRight do writeln('Array Right ke-',m,' : ',ArrRight[m]); {rekursif procedure mergesort dengan output akan disimpan di ArrLeft} msort(pjgLeft,ArrLeft,ArrLeft); {rekursif procedure mergesort dengan output akan disimpan di ArrRight} msort(pjgRight,ArrRight,ArrRight); {memanggil procedure merge untuk menyatukan ArrLeft dan ArrRight dan mengembalikan 1 array terurut melalui ArrHasil} merge(ArrLeft,pjgLeft,ArrRight,pjgRight,ArrHasil); end; end;

begin clrscr; write('banyak array : ');readln(x);

for m := 1 to x do begin write('Array ke-',m,' : '); readln(mrge1[m]); end; writeln; writeln('PROSES ='); writeln('-------------------'); msort(x,mrge1,mrge2); writeln; writeln('HASIL ='); writeln('---------------------'); for m:= 1 to x do writeln('Array Urut ke-',m,' : ',mrge2[m]); readln; end. Input:

Output :

RECCURENCE Reccurence merupakan persamaan atau pertidaksamaan yang menjelaskan sebuah fungsi yang bernilai lebih kecil dari inputnya. Cara menyelesaikan reccurence terbagi 3, yaitu sebagai berikut. 1. Metode Substitusi Dalam metode substitusi, kita perkirakan batasnya dan kemudian menggunakan induksi matematik dibuktikan kebenaran perkiraan kita tersebut. 1. Guess a solution 2. Use induction to prove that the solution works * Guess a solution - T(n) = O(g(n))

- Induction goal: apply the definition of the asymptotic notation T(n) d g(n), for some d > 0 and n n0 - Hipotesa Induksi: T(k) d g(k) for all k < n Contoh : T(n) = T(n-1) + n Guess: T(n) = O(n2) Induction goal: T(n) c n2, for some c and n n0 Hipotesa Induksi: T(n-1) c(n-1)2 for all k < n Proof of induction goal: T(n) = T(n-1) + n c (n-1)2 + n = cn2 (2cn c - n) cn2 if: 2cn c n 0 c n/(2n-1) c 1/(2 1/n) For n 1 2 1/n 1 any c 1 will work Induksi matematika mengharuskan untuk menunjukkan bahwa solusi kita berlaku untuk syarat batas. Biasanya, kita melakukannya dengan menunjukkan bahwa syarat batas yang cocok digunakan sebagai kasus dasar untuk pembuktian induktif.

2. Metode Iterasi atau Pohon Rekursif Metode ini digunakan dengan cara mengubah bentuk rekursif menjadi bentuk penjumlahan, kemudian diselesaikan dengan menggambar pohon rekursifnya.
Contoh: T(n) = 3T([n/4])+ n

Bila bentuk rekursif diuraikan: T(n) = n + 3T([n/4]) = n + 3([n/4]) + 3T(n/4[/4])) = n + 3([n/4]+ 3([n/16]+ 3T(n/64))) = n + 3n/4+ 9n/16+ 27T(n/64) Suku ke-i berbentuk 3in/4i Oleh karena n berkurang sebesar 4 pada setiap iterasi, maka proses berlangsung sampai log4N langkah . T(n) n + 3n/4 + 9n/16 + 27n/64 + . . .+ 3log4N N / N

 ( ) ( ) (

3. Metode Master Metode master melengkapi batas-batas untuk rekurensi dari bentuk T (n) aT (n / b) f (n) , 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. Contoh 1 Pertimbangkan pengulangan T (n) = 4T (n / 2) + n. Untuk kekambuhan ini, ada = 4 subproblems, masing-masing membagi masukan dengan b = 2, dan kerja yang dilakukan pada setiap panggilan adalah f (n) = n. Jadi n log b a adalah n 2, dan f (n) adalah O (n 2-) untuk = 1, dan Kasus 1 berlaku. Jadi T (n) adalah (n 2). Contoh 2 Perhatikan pengulangan T (n) = 4T (n / 2) + n 2. Untuk kekambuhan ini, ada lagi = 4 subproblems, masing-masing membagi masukan dengan b = 2, tapi sekarang kerja yang dilakukan pada setiap panggilan adalah f (n) = n 2. Lagi n log b a adalah n 2, dan f (n) dengan demikian (n 2), sehingga Kasus 2 berlaku. Jadi T (n) adalah (n 2 log n). Perhatikan bahwa peningkatan kerja pada setiap panggilan rekursif dari linear ke kuadrat telah meningkatkan waktu berjalan keseluruhan asimtotik hanya dengan faktor logaritmik. Contoh 3 Pertimbangkan pengulangan T (n) = 4T (n / 2) + n 3. Untuk kekambuhan ini, ada lagi = 4 subproblems, masing-masing membagi masukan dengan b = 2, tapi sekarang kerja yang dilakukan pada

setiap panggilan adalah f (n) = n 3. Lagi n log b a adalah n 2, dan f (n) dengan demikian (n 2 + ) untuk = 1. Selain itu, 4 (n / 2) 3 kn 3 untuk k = 1/2, sehingga Kasus 3 berlaku. Jadi T (n) adalah (n 3).