Nama: herianti Nim: H12111003 Alamat Blog: Heriantistatistik.blogspot.com A.

Pengertian Marge Sort Merge Sort adalah sebuah algoritma pengurutan data yang ditemukan oleh John von Neumann pada tahun 1945, algoritma ini merupakan bagian dari ilmu komputer yang dirancang untuk mengurutkan data yang jumlahnya sangat besar. Prinsip mendasar yang di gunakan pada algoritma merge sort sering disebut atau mengikuti pola pecah belah dan taklukan (divide and conquer).Pola divide and Conquer, adalah banyak diadopsi oleh beberapa alogirtma yang pada dasarnya mengimplementasikan konsep rekursi (adalah cara untuk menetapkan proses dengan dirinya sendiri) untuk memecahkan permasalahan. Caranya adalah permasalahan utama dipecah menjadi sub-masalah, kemudian solusi dari sub masalah akan di gabungkan untuk mendapatkan solusi dari masalah utama. Pada setiap tingkat rekursi pola tersebut terdiri atas 3 langkah : 1. Divide: membagi persoalan menjadi beberapa upa-masalah yang memiliki kemiripan dengan persoalan semula namun berukuran lebih kecil (idealnya berukuran hampir sama), 2. Conquer (solve): memecahkan (menyelesaikan) masing-masing upa-masalah secara rekursif. 3. Combine: mengabungkan solusi masing-masing upa-masalah sehingga membentuk solusi persoalan semula. B. Pengertian Rekursif Rekursif berarti bahwa suatu proses bisa memanggil dirinya sendiri. Menurut definisi dalam Microsoft Bookshelf, Rekursif adalah kemampuan suatu rutin untuk memanggil dirinya sendiri. Dalam Rekursif sebenarnya terkandung pengertian prosedur dan fungsi. Perbedaannya adalah bahwa rekursif bisa memanggil ke dirinya sendiri, tetapi prosedur dan fungsi harus dipanggil lewat pemanggil prosedur dan fungsi. Rekursif merupakan teknik pemrograman yang penting dan beberapa bahasa pemrograman mendukung keberadaan proses rekursif ini. Dalam prosedur dan fungsi, pemanggilan ke dirinya sendiri bisa berarti proses berulang yang tidak bisa diketahui kapan akan berakhir.Dalam pemakaian sehari-hari, rekursi merupakan teknik pemrograman yang berdaya guna untuk digunakan pada pekerjaan pemrograman dengan mengeksperisikannya ke dalam sukusuku dari program lain dengan menambahkan langkahlangkah sejenis.

Bentuk rekursif : a. suatu subrutin/fungsi/ prosedur yang memanggil dirinya sendiri. b. Bentuk dimana pemanggilan subrutin terdapat dalam body subrutin c. Dengan rekursi, program akan lebih mudah dilihat

Algoritma: 1. Untuk kasus n = 1, maka tabel A sudah terurut dengan sendirinya (langkah SOLVE). 2. Untuk kasus n > 1, maka (a) DIVIDE: bagi tabel A menjadi dua bagian, bagian kiri dan bagian masing-masing bagian berukuran n/2 elemen. (b) CONQUER: Secara rekursif, terapkan algoritma D-and-C masing bagian. kanan,

pada masing-

(c) MERGE: gabung hasil pengurutan kedua bagian sehingga diperoleh tabel A yang terurut.

Devide Combine

Time 1 n/2 T(n/2) T(n/2) O(n)

Contoh;

Implementasi Marge Short program MergeSort; uses crt; type arr = array [1..100] of integer; var ArrMain,ArrUrut : arr; n,m : integer; procedure merge(Left:arr; pjgL:integer; Right : arr; pjgR:integer; var ArrMerge : arr); {Menerima array left dan array right untuk dibandingkan dan disusun kembali ke array merge} {Hasil penggabungan ArrMerge} var i,j,k,m,panjang: integer; hasil : arr; 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]; akan dikembalikan melalui variabel output

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 mergesort1(pjg:integer;A : arr;var ArrHasil : arr); {Menerima Array yang akan dibagi menjadi 2 array yaitu array Left dan array Right} {Mengembalikan array yang terurut melalui variabel output ArrHasil} var middle,i,pjgLeft,pjgRight : integer; ArrLeft,ArrRight : arr; 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} mergesort1(pjgLeft,ArrLeft,ArrLeft); {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('Jumlah array : ');readln(n); for m := 1 to n do begin write('Array ke-',m,' : '); readln(ArrMain[m]); end; writeln; writeln('LANGKAH MERGE SORT'); writeln('-------------------'); mergesort1(n,ArrMain,ArrUrut); writeln; writeln('HASIL ARRAY TERURUT'); writeln('---------------------'); for m:= 1 to n do writeln('Array Urut ke-',m,' : ',ArrUrut[m]); readln; end.

C. Solving Recurrences Metode Subtitusi Metode substitusi untuk memecahkan rekurensi memerlukan dua langkah: 1. menebak bentuk solusi. 2.menggunakan induksi matematika untuk menemukan konstanta dan bahwa solusi bekerja. menunjukkan

Nama ini berasal dari substitusi menebak jawaban pada fungsi ketika hipotesis induktif diterapkan ke nilai yang lebih kecil. Metode ini sangat kuat, tetapi hanya dapat diterapkan dalam kasus saat mudah untuk menebak bentuk jawabannya. Metode substitusi dapat digunakan untuk membentuk batas atas ataupun bawah pada rekurensi. Sebagai contoh, mari kita menentukan batas atas rekurensi

Sesuai dengan rekurensi (4.2) dan (4.3). Kami menduga bahwa solusinya adalah T (n) = O (n lg n). Metode kami adalah untuk membuktikan bahwa T (n) cn lg n untuk pilihan yang tepat dari konstanta c> 0. Kita mulai dengan asumsi bahwa ini batas berlaku untuk n / 2 , yaitu, bahwa T ( n / 2 ) c n / 2 lg ( n / 2 ). Mensubstitusikan ke hasil perulangan

di mana langkah terakhir berlaku selama c 1. Induksi matematika saat ini mengharuskan kita 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. Untuk pengulangan (4.4), kita harus menunjukkan bahwa kita dapat memilih konstanta c cukup besar sehingga T batas (n) = cn lg n bekerja untuk syarat batas juga. Persyaratan ini kadang-kadang dapat menyebabkan masalah. Mari kita berasumsi, demi argumen, bahwa T (1) = 1 adalah kondisi batas tunggal perulangan. Kemudian untuk n = 1, T batas (n) = cn lg n menghasilkan T (1) = c1 lg 1 = 0, yang bertentangan dengan T (1) = 1. Akibatnya, kasus dasar bukti induktif kita gagal untuk dilanjutkan. Kesulitan ini membuktikan suatu hipotesis induktif untuk kondisi batas tertentu dapat dengan mudah diatasi. Misalnya, dalam pengulangan (4.4), kita mengambil keuntungan notasi asimtotik hanya yang kita membutuhkan untuk membuktikan T (n) = cn lg n untuk n n0, di mana n0 adalah konstanta yang kita pililih. Ide itu adalah untuk menghapus batas kondisi yang sulit T (1) = 1 dari pertimbangan dalam pembuktian induktif. Perhatikan bahwa untuk n> 3, perulangan tidak tergantung langsung pada T (1). Dengan demikian, kita dapat mengganti T (1) oleh T (2) dan T (3) sebagai dasar dalam kasus bukti induktif, diberikan n0 = 2. Perhatikan bahwa kita membuat perbedaan antara kasus dasar perulangan (n = 1) dan kasus dasar dari bukti induktif (n = 2 dan n = 3). Kita peroleh dari perulangan T (2) = 4 dan T (3) = 5. Bukti induktif bahwa T (n) cn lg n untuk beberapa konstanta c 1 sekarang dapat diselesaikan dengan memilih c yang cukup besar sehingga T (2) c2 lg 2 dan T (3) c3 lg 3. Ternyata, setiap pilihan c 2 sudah cukup untuk kasus dasar n = 2 dan n = 3 untuk diteruskan. Untuk sebagian besar rekurensi akan kita uji, itu sangat mudah untuk memperpanjang kondisi batas untuk membuat pekerjaan asumsi induktif untuk n kecil.

 Corrected proof: Bukti Dikoreksi: idenya adalah untuk memperkuat hipotesis induktif dengan cara mengurangkan istilah lower-order

Assume T (k ) c1k 2 c2 k for k n T (n) 4T (n / 2) n 4(c1 (n / 2) 2 c2 (n / 2)) n c1n 2 2c2 n n c1n 2 c2 n (c2 n n) c1n 2 c2 n if c2 1
Metode Iterasi Metode iterasi tidak memerlukan tebakan solusinya, tetapi memerlukan manipulasi aljabar yang lebih intensif dari pada metode substitusi. Ide dasarnya adalah dengan mengembangkan bentuk rekursif tersebut serta merepresentasi-kannya dalam bentuk jumlah. Teknik untuk mengevaluasi bentuk jumlah dapat digunakan untuk mendapatkan nilai batas dari solusinya. 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 Contoh: T(n) = aT([n/4])+ n Untuk a=3

: ( 2 )

Figure 4.1: The construction of a recursion tree for the recurrence T(n) = 3T(n/4) + cn2. Part (a) shows T(n), which is progressively expanded in (b)-(d) to form the recursion tree. The fully expanded tree in part (d) has height log4 n (it has log4 n + 1 levels).

Metode Master Metode master menyediakan semacam cookbook untuk menyelesaikan persamaan rekursif dalam bentuk: T(n) = aT(n/b) + f(n) dengan a 1 dan b > 1 adalah konstanta dan f(n) adalah fungsi yang secara asimtotik positif. Dalam metode master perlu diingat 3 kasus, namun sesudahnya bentuk-bentuk rekursif dapat diselesaikan dengan lebih mudah. Kasus I: T(n) = aT(n/b) + f(n) a1, b>1

jika f(n) = O(nlogb(a-)), > 0 maka T(n) = (nlogba) f(n) secara polinomial lebih kecil dari nlogba dengan faktor n, shg nlog ba mendominasi

Kasus II: T(n) = aT(n/b) + f(n) a1, b>1

jika f(n) = (nlogba) maka T(n) = (nlogbalog n) cost setiap langkah adalah nlogba sehingga, padahal ada sebanyak log n langkah, jadi T(n) = (nlogbalog n)

Kasus III: T(n) = aT(n/b) + f(n) a1, b>1

jika f(n) = (nlogb(a+)), > 0 dan a f(n/b) c f(n) untuk c < 1 maka T(n) = (f(n)) dhi, f(n) > nlogba dgn faktor polinomial sehingga suku dominan adalah f(n) + f(n/b) + f(n/b2) O(f(n))