Nama : Zaenal

Nim` : H12111002
Tugas : Algoritma Dan Struktur Data
1. 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.
Algoritma pengurutan data merge sort dilakukan dengan menggunakan cara divide and
conquer yaitu dengan memecah kemudian menyelesaikan setiap bagian kemudian
menggabungkannya kembali. Pertama data dipecah menjadi 2 bagian dimana bagian pertama
merupakan setengah (jika data genap) atau setengah minus satu (jika data ganjil) dari seluruh
data, kemudian dilakukan pemecahan kembali untuk masing-masing blok sampai hanya terdiri
dari satu data tiap blok.
Setelah itu digabungkan kembali dengan membandingkan pada blok yang sama apakah data
pertama lebih besar daripada data ke-tengah+1, jika ya maka data ke-tengah+1 dipindah sebagai
data pertama, kemudian data ke-pertama sampai ke-tengah digeser menjadi data ke-dua sampai
ke-tengah+1, demikian seterusnya sampai menjadi satu blok utuh seperti awalnya. Sehingga
metode merge sort merupakan metode yang membutuhkan fungsi rekursi untuk penyelesaiannya.
Dengan hal ini 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
Selesaikan sub masalah tersebut secara rekursif. Jika sub-masalah tersebut cukup ringkas dan
sederhana, pendekatan penyelesaian secara langsung akan lebih efektif
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.


Memahami Merge Sort
Seperti yang telah dijelaskan sebelumnya, Merge sort menggunakan pola divide and conquer.
Dengan hal ini 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 secara rekursif.
3. Kombinasi Mengkombinasikan dua bagian tersebut secara rekursif untuk mendapatkan
rangkaian 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.
Algoritma
void mergeSort(Object array[], int startIdx, int endIdx)
{ if (array.length != 1)
{ //Membagi rangkaian data, rightArr dan leftArr
mergeSort(leftArr, startIdx, midIdx);
mergeSort(rightArr, midIdx+1, endIdx);
combine(leftArr, rightArr); } }
Contoh
1. Rangkaian data:


Membagi rangkaian menjadi dua bagian:
LeftArr RightArr
7 2

Membagi LeftArr menjadi dua bagian:
7 2 6 5
6 5
LeftArr RightArr
7 2

Mengkombinasikan
2 7

Membagi RightArr menjadi dua bagian:
LeftArr RightArr
6 5

Mengkombinasikan
5 6

Mengkombinasikan LeftArr dan RightArr.


2. penerapan atas sebuah larik sebagai data sumber yang akan diurutkan {3, 9, 4, 1, 5, 2} adalah
sebagai berikut:
- 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.
o {1, 2} <-> {3, 4, 9} dan {5}
o {1, 2, 3} <-> {4, 9} dan {5}
o {1, 2, 3, 4} <-> {9} dan {5}
o {1, 2, 3, 4, 5} <-> {9} dan {null}
o {1, 2, 3, 4, 5, 9} <-> {null} dan {null}
2 5 6 7
Contoh program sedehana merge sort
public class mergeSort{
public static void main(String a[]){
int i;
int array[] = {7,5,1,3,6,4,9,8};
System.out.println("\n\n Kelompok 3\n\n");
System.out.println(" Pengurutan dengan Merge Sort\n\n");
System.out.println("Data Sebelum Diurutkan:\n");
for(i = 0; i < array.length; i++)
System.out.print( array[i]+" ");
System.out.println();
mergeSort_srt(array,0, array.length-1);
System.out.print("Data Setelah Diurutkan:\n");
for(i = 0; i <array.length; i++)
System.out.print(array[i]+" ");
System.out.println();
}
public static void mergeSort_srt(int array[],int lo, int n){
int low = lo;
int high = n;
if (low >= high)
{return; }
int middle = (low + high) / 2;
mergeSort_srt(array, low, middle);
mergeSort_srt(array, middle + 1, high);
int end_low = middle;
int start_high = middle + 1;
while ((lo <= end_low) && (start_high <= high))
{
if (array[low] < array[start_high]) {
low++; }
else {
int Temp = array[start_high];
for (int k = start_high- 1; k >= low; k--)
{array[k+1] = array[k]; }
array[low] = Temp;
low++;
end_low++;
start_high++; }
}
}


2. RECURENCE/REKURSI

Ada tiga metode penyelesaian rekursi :
1. Metode Subtitusi
2. Metode Iterasi
3. Metode Teorema Master

1. Metode Substitusi
Pertama-tama dibuat suatu guess dari bentuk solusinya.
Gunakan induksi matematika untuk membuktikan bahwa guess itu benar.
Contoh:
- T(n) = 4T (n/2) + n
1.) anggap T(n) = O

2.) asumsi T() = C

3.) buktikan T(n)

dengan induksi
T(n) = 4T (n/2) + n
4

+ n
=

jika dan
Kemudian T(n) = O(

Subtitusi : harus memilih c yang cukup besar untuk bisa menangani
T(n) = untuk

untuk beberapa

- T(n) = 2(T(n/2)) + n
1.) Pertama, dibuat guess dari solusinya adalah T(n) = O(n lg n)
2.) Kedua, dibuktikan dengan induksi matematis bahwa solusi di atas benar, yaitu
dibuktikan bahwa T(n) s c (nlgn)

Basis untuk n = 2,
T(2) = 2(T(2/2))+ 2 = 4 s c (2lg2), dengan c > 2
Anggap solusi diatas berlaku untuk n/2, yaitu T(n/2) s c (n/2) lg (n/2)
Dibuktikan bahwa solusi diatas berlaku untuk n
Substitusikan pertidaksamaan T(n/2) s c (n/2) lg (n/2) ke rekurensi, diperoleh:
T(n) s 2 (c (n/2) lg (n/2)) + n
s cn lg (n/2) + n
s cn lg (n) cn lg 2 + n
= cn lg n cn + n
s cn lg n, untuk c > 1 (terbukti)
Jadi batas atas dari rekurensi diatas adalah T(n) = O (n lg n)

2. Metode Iterasi/Pohon Rekursif
Selain metode subtitusi metode yang kedua yaitu metode iterasi atau pohon
rekursif,metode ini digunakan karena dalam metode subtitusi kadang kita sulit untuk
menebak dengan baik solusi dari algoritma ini oleh karena itu menggambar sebuah pohon
rekursi berfungsi sebagai cara mudah untuk menebak dengan baik. Dalam pohon rekursi,
setiap node mewakili nilai subproblem tunggal di suatu tempat di set fungsi rekursif.
Metode ini ide dasarnya adalah dengan memperluas recurence dan mengubahnya
kedalam bentuk penjumlahan.














( )
( ) ( )
( ) ( ) ( )
( )
( )
4
4
4
log
log 1
log 3
0
( ) 3 / 4
3 / 4 3 /16
3 / 4 3 /16 3 / 64
3 / 4 9 /16 27 / 64
( ) 3 / 4 9 /16 27 / 64 ... 3 (1)
3

4
4 ( )
( )
n
i
n
i
T n n T n
n n T n
n n n T n
n n n T n
T n n n n n T
n n
n o n
O n

=
= + (

= + + ( (

= + + + ( ( (

= + + + ( ( (

= + + + + +
| |
s + O
|
\ .
s +
s

Selain cara di atas ada cara yang lebih mudah yaitu dengan pohon rekursi


Jika digambarkan dengan pohon rekursi :

















1. Metode Master
Metode master menyediakan semacam cookbook untuk menyelesaikan persamaan
rekursif dalam bentuk:


dengan a 1 dan b > 1 adalah konstanta , f(n) adalah fungsi yang secara asimtotik
positif dan T(n) didefinisikan sebagai bilangan bulat nonnegatife oleh rekurens.
Dalam metode master perlu diingat 3 kasus, namun sesudahnya bentuk-bentuk
rekursif dapat diselesaikan dengan lebih mudah.








( ) ( / 3) (2 / 3) T n T n T n n = + +
L
a
m
a
n
y
a
r
u
n
n
i
n
g
t
i
m
e

( ) ( / ) ( ) T n aT n b f n = +
( )
( )
( )
( )
( )
( )
log
log
log
log
log
0
1. ( )
( )
2. ( )
( ) lg
3. ( ) and ( / ) ( ), for some 1,
( ) ( )
b
b
b
b
b
a
a
a
a
a
f n O n
T n n
f n n
T n n n
f n n af n b cf n c n n
T n f n
c
+c
=
= O
= O
= O
= O s < >
= O
Dari ketiga persamaan Metode Master di atas tidak dapat diselesaikan setiap
recurrence,karena ada perbedaan antar kasus 1, dan 2 serta kasus 2 dan 3

a. Case 1
T(n) = 2 T(n/2) + n
T(n) = aT (n/b) + f(n)

T(n) =
T(n) = (

b. Case 2
T(n) = 2T (n/2) +

T(n) =

c. Case 3
T(n) = 4T (n/2) + n

T(n) =