Nama NIM

: Maya Mulyasari : H12111277 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. Prinsip utama yang diimplementasikan pada algoritma merge-sort seringkali disebut sebagai divide and conquer. Menurut keefektifannya, alogaritma ini bekerja dengan tingkat keefektifan O(nlog(n)). Merge sort ini memanfaatkan sebuah fungsi merge dengan spesifikasi mengurutkan 2 buah list yang elemen tiap list sudah terurut. Dengan ide ini list yang akan diproses dibagi-bagi dulu menjadi list yang lebih kecil hingga tinggal satu elemen. Setelah itu digabung kembali dari dua list menjadi satu, lalu digabung kembali terus sampai menjadi 2 list besar yang setelah dimerge akan menghasilkan list yang sudah terurut. Sorting jenis ini sangat berguna saat kita akan memproses jumlah elemen yang sangat banyak. Konsep dari merge sort sendiri adalah sebagai berikut : 1. Bagi list besar menjadi setengahnya. 2. Lakukan hal ini secara rekursif sampai diperoleh list dengan satu elemen saja. 3. List tersebut digabung lagi menjadi sebuah list besar yang sudah terurut. Metode untuk desain algoritma :
Divide : jika ukuran data input sangat besar untuk dieksekusi secara langsung, bagi

masalah menjadi dua atau lebih submasalah. Jika S setidaknya terdapat dua elemen (tidak ada yang perlu dilakukan jika S nol atau satu elemen), hapus semua elemen dari S dan tempatkan mereka kedalam dua bagian urutan bilangan, , masing-masing berisi sekitar setengah dari elemen S. (misalkan unsur-unsur yang tersisa. berisi unsur pertama dari dan berisi

Conquer : divide dan conquer rekursif untuk memecahkan submasalah. Mengurutkan

urutan

menggunakan MergeSort.

Combine : ambil solusi untuk submasalah dan gabungkan solusi menjadi solusi untuk

masalah sebenarnya. Mengembalikan elemen yang telah terurut ke S dengan menggabungkan urutan menjadi satu urutan yang telah terurut.

Suatu implementasi pseudocode sederhana yang tak berulang dari penggabungan dengan dua daftar yang mungkin tertulis sebagai berikut: function merge(a, b) var list result var int i, j := 0 while (i < length(a)) and (j < length(b)) if a[i] < b[j] add a[i] to result i := i + 1 else add b[j] to result j := j + 1 while i < length(a) add a[i] to result i := i + 1

while j < length(b) add b[j] to result j := j + 1 return result

Implementasi algoritma merge menggunakan MATLAB M-File : function p=merge(a,b) % MERGE Penggabungan % MERGE(A,B) menggabungkan dua list if nargin<2 error('Kekurangan argumen input'); end % pengecekan error a=a(:); % meyakinkan bahwa input merupakan vektor baris b=b(:); na=length(a); % menemukan panjang a dan b nb=length(b); df=a+b; % hasil dari daftar ndf=length(df); p=[zeros(1,nb-na) a]+[zeros(1,na-nb) b];

Command window >> a=[1 2 3] a= 1 2 3

>> b=[2 3 4] b= 2 3 4

>> merge(a,b) ans = 3 5 7 >> p=[3 5 7] p= 3 5 7

>> for i=1:3 x=a(i)+p(i) end x= 4 x= 7 x= 10 >> for j=1:3 y=b(j)+p(j) end y= 5 y= 8 y= 11

Contoh program pengurutan dengan penggabungan atau merge sort : void mergeSort (int *T, int *temp, int Nmax) /*I.S. T tabel dgn elemen bertipe*/ /* integer, T tidak kosong*/ /*F.S T terturut menaik*/ /* Proses : melakukan pengurutan*/ /* dengan melakukan metode sort*/ { m_sort (T, temp, 0, Nmax -1); } void m_short (int *T, int *temp, int *left, int *right) { int mid; if (*right > *left) { mid = (*right + *left) / 2; m_sort (T, temp, left, mid); m_sort (T, temp, mid+1, right); merge (T, temp, left, mid+1, right); } } void merge(int *T, int * temp, int left, int mid, int right) { int i, left_end, num_elements, tmp_pos; left_end + mid-1; tmp_pos = left; num_elements = right left + 1; while ((left <= left_end) && (mid <= right)) { if (*T[left] <= *T[mid]) { *temp[tmp_pos] = *T[left]; tmp_pos = tmp_pos +1; left = left +1; } else { *temp [tmp_pos] = *T [mid]; tmp_pos = tmp_pos + 1; mid = mid +1; } }

while (left <= left_end); { *temp[tmp_pos] = *T[left]; left = left +1; tmp_pos = tmp_pos +1; } while (mid <= right) { *temp [tmp_pos] = *T [mid]; mid = mid +1; tmp_pos = tmp_pos + 1; } for (i=0; i <= num_elements; i++) { *T[right] = *temp[right]; right = right -1; } } Karena algoritma merge sort adalah algoritma yang dijalankan secara rekursif maka T(n) dari algoritma ini adalah:

Sehingga, algoritma merge sort memiliki kompleksitas algoritma O(n log n). Algoritma merge sort ini sebenernya lebih cepat dibandingkan heap sort untuk tabel yang lebih besar. Namun, algoritma ini membutuhkan setidakny ruang atau emori dua kali lebih besar karena dilakukan secara rekursif dan memakai dua tabel. Hal ini menyebabkan algoritma ini kurang banyak dipakai.

RECURRENCE
Rekursi berarti suatu proses yang bisa memanggil dirinya sendiri. Suatu rekurensi adalah suatu persamaan atau pertidaksamaan yang menyatakan suatu fungsi dengan harga fungsi tersebut pada input yang ukurannya lebih kecil Dalam pemrograman, rekursi merupakan teknik programming yang berdaya guna untuk digunakan pada pekerjaan pemrograman dengan mengekspresikannya ke dalam suku-suku dari program lain dengan menambahkan langkah-langkah sejenis.

Contoh proses menghitung nilai faktorial Faktorial (0) = 1 ..................(1) Faktorial (N) = N * Faktorial (N-1), N > 0 ...........(2)

Persamaan (1) yang tidak bersifat rekursif disebut nilai awal. Persamaan (2) merupakan contoh hubungan rekurensi, yang berarti bahwa nilai suatu fungsi dengan argumen tertentu bisa dihitung dari fungsi yang sama dengan argumen yang lebih kecil. Setiap fungsi rekursi paling sedikit memiliki 1 nilai awal, jika tidak, fungsi tersebut tidak bisa dihitung secara eksplisit.

Metode Penyelesaian Rekursi Misalkan : Merge Sort (1) if n = 1 T ( n) = 2T (n / 2) + (n) if n > 1

Ukuran running time pada suatu algoritma pada input yang konstan adalah konstan, maka untuk n cukup kecil, rekurensi yang menyatakan running time algoritmanya adaah T(n) = (1). Oleh karena itu biasanya syarat batas dari rekurensi tidak dituliskan dan dianggap bahwa T(n) adalah konstan untuk n cukup kecil.

Metode untuk menyelesaikan rekurensi (yaitu untuk memperoleh batas O, , dan secara asimtotik) ada 3 (tiga) metode yang dapat kita gunakan untuk pemecahan rekursif yaitu: metode substitusi, metode iterasi, dan teorema master. 1. Metode Subsitusi Pertama-tama dibuat suatu guess dari bentuk solusinya. Gunakan induksi matematika untuk membuktikan bahwa guess itu benar. Metode ini dapat digunakan untuk menentukan baik batas atas maupun batas bawah suatu rekurensi. Contoh: Tentukan batas atas dari T(n) = 2(T( n/2 )) + n Jawab: Pertama, dibuat guess dari solusinya adalah T(n) = O(n lg n) Kedua, dibuktikan dengan induksi matematis bahwa solusi di atas benar, yaitu dibuktikan bahwa T(n) c (nlgn) Basis untuk n = 2, T(2) = 2(T(2/2))+ 2 = 4 c (2lg2), dengan c 2

Anggap solusi diatas berlaku untuk n/2 , yaitu ( n/2 ) Dibuktikan bahwa solusi diatas berlaku untuk n

T( n/2 ) c ( n/2 ) lg

Substitusikan pertidaksamaan T( n/2 ) c ( n/2 ) lg ( n/2 ) ke rekurensi, diperoleh: T(n) 2 (c ( n/2 ) lg ( n/2 )) + n cn lg (n/2) + n cn lg (n) cn lg 2 + n = cn lg n cn + n cn lg n, untuk c 1 (terbukti) Jadi batas atas dari rekurensi diatas adalah T(n) = O (n lg n)

2. Metode Iterasi Prinsip dari metode iterasi adalah menjabarkan rekurensi sebagai suatu bentuk penjumlahan yang hanya bergantung pada n dan syarat awal. 3. Metode /Teorema Master Misalkan T(n) adalah fungsi menaik yang memenuhi relasi rekurens: T(n) = aT(n/b) + cnd dalam hal ini n = bk , k = 1, 2, , a 1, b 2, dan c dan d adalah bilangan riil 0, maka
T(n) adalah )

Contoh: Pada algoritma Mergesort/Quick Sort, Menurut Teorema Master, a = 2, b = 2, d = 1, dan a = bd, maka relasi rekurens: T(n) = 2T(n/2) + cn = O(n log n)