Upload
heriantis-data
View
150
Download
1
Embed Size (px)
DESCRIPTION
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
Citation preview
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))