Nama : sy.

Fakhriah fildzah

Nim: H121 11 102

RESUME
A. 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.
Cara kerja algoritma merge sort adalah membagi array data yang ada menjadi dua bagian
yang sama panjang atau paling tidak berselisih 1. Kedua array yang baru juga di bagi dua,
dan seterusnya sampai tidak bisa di bagi lagi.
Setelah semua array terpecah dan tidak bisa dibagi lagi, maka array tunggal tersebut di
urutkan dan di letakkan pada array baru sebagai hasil akhir.

Prinsip utama yang diimplementasikan pada algoritma merge-sort seringkali disebut

sebagaipecah-belah dan taklukkan (bahasa Inggris: 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)).

deskripsi dari algoritma dirumuskan dalam 3 langkah berpola divide-and-conquer. Berikut

menjelaskan langkah kerja dari Merge sort.
1. Divide
Memilah elemen elemen dari rangkaian data menjadi dua bagian.
2. Conquer
Conquer setiap bagian dengan memanggil prosedur merge sort secararekursif
3. Kombinasi
Mengkombinasikan dua bagian tersebut secara rekursif untuk mendapatkanrangkaian data
berurutan
Proses rekursi berhenti jika mencapai elemen dasar. Hal ini terjadi bilamana bagian yang
akan diurutkan menyisakan tepat satu elemen. Sisa pengurutan satu elemen tersebut
menandakan bahwa bagian tersebut telah terurut sesuai rangkaian.

Contoh penerapan atas sebuah larik/array sebagai data sumber yang akan diurutkan {3, 9, 4,
1, 5, 2} adalah sebagai berikut:
pertama kali larik tersebut dibagi menjadi dua bagian, {3, 9, 4} dan {1, 5, 2}
Kedua larik kemudian diurutkan secara terpisah sehingga menjadi {3, 4, 9} dan {1, 2, 5}
Sebuah larik baru dibentuk yang sebagai penggabungan dari kedua larik tersebut {1},
sementara nilai-nilai dalam masing larik {3, 4, 9} dan {2, 5} (nilai 1 dalam elemen larik ke dua
telah dipindahkan ke larik baru)
langkah berikutnya adalah penggabungan dari masing-masing larik ke dalam larik baru
yang dibuat sebelumnya.
{1, 2} <-> {3, 4, 9} dan {5}
{1, 2, 3} <-> {4, 9} dan {5}
{1, 2, 3, 4} <-> {9} dan {5}
{1, 2, 3, 4, 5} <-> {9} dan {null}
{1, 2, 3, 4, 5, 9} <-> {null} dan {null}

Persoalan Minimum dan Maksimum (MinMaks)

Persoalan : Misalnya diketahui table A yang berukuran n eleman sudah berisi nilai integer.
Kita ingin menentukan nilai minimum dan nilai maksimum sekaligus di dalam table tersebut.
Misalkan tabel A berisi elemen-elemen sebagai berikut :
Ide dasar algoritma secara Divide and Conquer :

Ukuran table hasil pembagian dapat dibuat cukup kecil sehingga mencari minimum dan
maksimum dapat diselesaikan (SOLVE) secara lebih mudah. Dalam hal ini, ukuran kecil yang
dipilih adalah 1 elemen atau 2 elemen.

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,

DIVIDE : Bagi dua table A secara rekursif menjadi dua bagian yang berukuran sama, yaitu
bagian kiri dan bagian kanan.

CONQUER : Terapkan algoritma Divide and Conquer untuk masing-masing bagian, dalam hal
ini min dan maks dari table bagian kiri dinyatakan dalam peubah min1 dan maks1, dan min
dan maks dari table bagian kanan dinyatakan dalam peubah min2 dan maks2.

COMBINE : Bandingkan min1 dan min2 untuk menentukan min table A, serta bandingkan
maks1 dan maks2 untuk menentukan maks table A.

Berikut contoh program merge sort dengan rekursif:

uses crt;

var

a,b,n,i,tamp : integer;

data : array [byte] of integer;

procedure urut;

begin

for i:=1 to n do

begin

write('Input Data ke-',i,' = ');readln(data[i]);

end;

{Pengurutan Data}

For a:=1 to n do

for b:=1 to a do

if data[a] < data[b] then

begin

tamp := data[a];

data[a] := data[b];

data[b] := tamp;

end;

write('Hasil Pengurutan = ');

{Pencatakan Data Setelah DiUrutkan}

For a:=1 to n do

write(data[a],' ');

readln;end;

begin
clrscr;

write('Masukkan Jumlah Bilangan = ');readln(n);

{Penginputan Data}

urut;

end.

Hasilnya:

B. RECURENCE

Rekurensi adalah suatu persamaan atau pertidaksamaan yang menguraikan fungsi dalam
suku-suku nilai input yang lebih kecil. ada tiga metode untuk menyelesaikan rekurensi, yaitu
untuk mendapatkan batas asymptotic "" atau "O" pada solusi. Ketiga metode tersebut
adalah metode iterasi, substitusi, metode master.

1. Metode Iterasi.

Metode iterasi mengkonversi rekurensi ke dalam jumlahan dan kemudian berdasarkan cara
untuk bounding summations untuk menyelesaikan rekurensi.
 Contoh 1:

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

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

= 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 2:

T ( n) n 3T n / 4

n 3 n / 4 3T n /16

n 3 n / 4 3 n /16 3T n / 64
n 3 n / 4 9 n /16 27T n / 64
T ( n) n 3n / 4 9n /16 27 n / 64 ... 3log 4 n T (1)
log 4 n 1 i
3
n n
log 4 3

i 0 4
4n o( n)
O ( n)

Selain cara di atas ada cara yang lebih mudah, yaitu pohon rekursif:
T (n) T (n / 4) T (n / 2) n 2
 T (n) T (n / 3) T (2n / 3) n

L
a
m
a
n
y
a
r
u
n
n
i
n
g
t
i
m
e

2. Metode subtitusi:

Dalam metode substitusi, kita perkirakan batasnya dan kemudian menggunakan induksi
matematik dibuktikan kebenaran perkiraan kita tersebut.

Contoh 1:

T(n) = 4T (n/2) + n
1.) anggap T(n) = O (3 )
2.) asumsi T() = C 3
3.) buktikan T(n) 3 dengan induksi
T(n) = 4T (n/2) + n
4 (/2)3 + n

= 2 3 +

= 3 (2 3 )
3 jika 2 dan 1

Kemudian T(n) = O(2 )!

Subtitusi : harus memilih c yang cukup besar untuk bisa menangani

 T(n) = (1) untuk < 0 untuk beberapa 0

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. Metode master
merupakan salah satu metode penyelesaian running time dengan 3 cara berbeda
untuk 3 kasus yang berbeda pula.
Mengingat recurence yang diberikan T (n) aT (n / b) f (n) maka ada 3
kasus, yaitu:

Contoh 1:
1.
f (n) O n logb a

T (n) n logb a
2.
f (n) n logb a

T (n) n logb a lg n
3.
f (n) n logb a and af (n / b) cf (n), for some c 1, n n0
T ( n) f ( n)

Ketiga persamaan di atas tidak dapat menyelesaikan setiap recurence karena ada
perbedaan antara kasus 1 dan 2 serta kasus 2 dan 3.

a. Contoh ini menggunakan kasus 2.

T(n) = 2 T(n/2) + n
T(n) = aT (n/b) + f(n)
log = log

log = log2 2
() =

T(n) = . lg

T(n) = 2 (2) + 2
b. Contoh ini menggunakan kasus 3.
T(n) = 2T (n/2) + 2
log = log2 2+1
() = 2

T(n) = (2 )

c. Contoh ini menggunakan kasus 1.

T(n) = 4T (n/2) + n
log2 4 = 21 =
T(n) = (2 )