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 suku-

suku 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 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 tabel A

yang terurut.

Time

1

n/2

T(n/2)

T(n/2)

O(n)

Devide

Combine

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 akan dikembalikan melalui variabel output

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];

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 menunjukkan

bahwa solusi bekerja.

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

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/4

i

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

1 2

2

1 2

2

1 2

2

1 2 2

2

1 2 2

Assume ( ) for

( ) 4 ( / 2)

4( ( / 2) ( / 2))

2

( )

if 1

T k c k c k k n

T n T n n

c n c n n

c n c n n

c n c n c n n

c n c n c

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

𝑇𝑜𝑡𝑎𝑙:𝑂( 𝑛2)

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) a ≥ 1 , b > 1

jika f(n) = O(nlogb

(a-ε)), ε > 0 maka T(n) = Θ(nlog

ba)

f(n) secara polinomial lebih kecil dari nlogb

a dengan faktor nε, shg nlogb

a mendominasi

Kasus II:

T(n) = aT(n/b) + f(n) a ≥ 1 , b > 1

jika f(n) = Θ(nlogb

a) maka T(n) = Θ(nlog

balog n)

cost setiap langkah adalah nlogb

a sehingga, padahal ada sebanyak log n langkah, jadi T(n) = Θ(nlog

balog n)

Kasus III:

T(n) = aT(n/b) + f(n) a ≥ 1 , 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) > nlogb

a dgn faktor polinomial sehingga suku dominan adalah f(n) + f(n/b) + f(n/b2)… O(f(n))