Algoritma Merge Sort

ALGORITMA MERGE SORT DAN REKURENS

SRY WAHYUNIH12111292Statistika Unhas

ALGORITMA MERGE SORTMerge 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. (id.wikipedia.org)

Divide, conquer, dan combineAlgoritma 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.

Algoritma Merge Sort ialah algoritma pengurutan yang berdasarkan pada strategi divide and conquer. Algoritma Merge Sort dilakukan dengan memenuhi kondisi sebagai berikut : 1. Untuk kasus n=1, maka table a sudah terurut sendirinya (langkah solve)2. Untuk kasus n>1, maka :

a) DIVIDE: bagi table 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 table a yang terurut.

Dengan menerapkan kedua aturan diatas secara terus menerus maka nantinya akan didapatkan list yang terurut. Pseudo Code untuk algoritma MergeSort adalah sebagai berikut:

Untuk menyederhanakan perhitungan kompleksitas waktu MergeSort, kita membuat asumsi ukuran tabel adalah perpangkatan dari 2, yaitu n=2k dengan k adalah bilangan bulat positif2. Kompleksitas waktu dihitung dari jumlah perbandingan dengan elemen-elemen tabel.

Algoritma Merge Sort dan Rekurens

T(n) = jumlah perbandingan pada pengurutan dua buah subtabel + jumlah perbandingan pada prosedur Merge.

Kompleksitas prosedur Merge adalah t(n) = cn = O(n), sehingga kompleksitas algoritma Merge Sort menjadi (dalam bentuk relasi rekurens):

Τ (n){ α ,n=1

2Τ ( n2 )+cn ,n>1

dalam hal ini,a dan c adalah konstanta. Penyelesaian persamaan rekurens: T(n) =T(n/2)+cn = 2(2T(n/4) + cn/2) + cn = 4T(n/4) + 2cn = 4(2T(n/8) + cn/4) + 2 cn = ... = 2k T(n/2k)+kcn

Divide and Conquer merupakan algoritma yang berprinsip memecah-mecah permasalahan yang terlalu besar menjadi beberapa bagian kecil sehingga lebih mudah untuk diselesaikan. Langkah-langkah umum algoritma Divide and Conquer : Divide : Membagi masalah menjadi beberapa upa-masalah yang memiliki kemiripan dengan

masalah semula namun berukuran lebih kecil ( idealnya berukuran hampir sama ). Conquer : Memecahkan ( menyelesaikan ) masing-masing upa-masalah ( secara rekursif ). Combine : Menggabungkan solusi masing-masing upa-masalah sehingga membentuk solusi

masalah semula.

Merge sort pseucodeMerge-Sort(A, p, r): if p < r then q¬(p+r)/2 Merge-Sort(A, p, q) Merge-Sort(A, q+1, r) Merge(A, p, q, r)

if p < r then Bagian ini di proses sebanyak O(1).

q¬(p+r)/2Pernyataan ini akan dieksekusi sebanyak n/2. Karena data dibagi dua.

Merge-Sort(A, p, q)Merge-Sort(A, q+1, r)

Pernyataan ini waktu komputasinya adalah T(n/2). Pada bagian ini merupakan proses divide yaitu data dipecah (dibagi-bagi) hingga potongan terkecil.


Merge(A, p, q, r)Pernyataan ini waktu komputasinya adalah O(n). Bagian ini merupakan proses combine, yaitu data digabungkan kembali.

ContohPenyelesaian dengan dengan Divide and Conquer.Misalkan tabel A berisi elemen-elemen sebagai berikut:A= 4 12 23 9 21 1 35 2 24

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,

(a)DIVIDE: Bagi dua tabel A secara rekursif menjadi dua bagian yang berukuran sama, yaitu bagian kiri dan bagian kanan.

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

(c) COMBINE:Bandingkan min1 dengan min2 untuk menentukan min tabel ABandingkan maks1 dengan maks2 untuk menentukan maks tabel A.


Tinjau kembali soal di atasDIVIDE dan CONQUER: Bagi tabel menjadi dua bagian sempai berukuran 1 atau 2 elemen:

4 12 23 9 21 1 35 2 24

4 12 23 9 21 1 35 2 24

4 12 23 9 21 1 35 2 24

SOLVE dan COMBINE: Tentukan min dan maks masing-masing bagian tabel, lalu gabung:

4 12 23 9 21 1 35 2 24 min = 4 min = 9 min = 1 min = 35 min = 2maks = 12 maks = 23 maks = 21 maks =35 maks = 24

4 12 23 9 21 1 35 2 24 min = 4 min = 1 min = 2maks = 23 maks = 21 maks = 35

4 12 23 9 21 1 35 2 24 min = 4 min = 1maks = 23 maks = 35

4 12 23 9 21 1 5 2 24 min = 1maks = 35

Jadi, nilai minimum tabel = 1 dan nilai maksimum = 35.

Merge Sort : contoh lainPertama, data dibagi 2 bagian, selanjutnya tiap bagian dibagi lagi menjadi dua bagian, demikian selanjutnya hingga data tidak dapat dibagi lagi. Tahap ini merupakan divide.


Setelah dibagi hingga potongan terkecil, data tesebut diurutkan kembali.


Setelah data diurutkan kembali, maka tahap terakhir adalah data tersebut disatukan/dikombain.

Implementasi Merge Sort :#include <stdio.h>#include <stdlib.h>#include <string.h>

void printv(char* in, int *v, int n) {printf("%s", in);int i = 0;for (; i < n; ++i)

printf("%d ", v[i]);printf("\n");

}

void merge(int *v, int p, int q, int r) {int i = p;int j = q + 1;

int *tmp = (int*)malloc((r - p + 1) * sizeof(int));int k = 0;

while ((i <= q) && (j <= r)) {if (v[i] < v[j])

tmp[k++] = v[i++];else

tmp[k++] = v[j++];}

while (i <= q)tmp[k++] = v[i++];

while (j <= r)


tmp[k++] = v[j++];

memcpy(v + p, tmp, (r - p + 1) * sizeof(int));free(tmp);

}

void mergeS(int *v, int p, int r) {if (p < r) {

int q = (p + r) / 2;mergeS(v, p, q);mergeS(v, q + 1, r);merge(v, p, q, r);

}}

int main(int argc, char *argv[]) {int n = 10;int v[] = {9, 8, 7, 6, 5, 5, 4, 3, 2, 1};printv("V: ", v, n);mergeS(v, 0, n - 1);printv("V: ", v, n);

return 0;}

Output:

RECURRENCERecurrence adalah fungsi yang memanggil dirinya sendiri. Rekurensi adalah suatu persamaan atau pertidaksamaan yang menguraikan fungsi dalam suku-suku nilai input yang lebih kecil.Pada bagian ini ada tiga metode untuk menyelesaikan rekurensi, yaitu untuk mendapatkan batas

asymptotic Θ atau O pada solusi. Ketiga metode adalah metode iterasi, substitusi, metode master.

Menyelesaikan fungsi recurrence, terdapat 3 metode, yakni:1. Metode substitusi

o Pertama-tama dibuat suatu “guess” dari bentuk solusinya.o Gunakan induksi matematika untuk membuktikan bahwa guess itu benar.


o 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û)) + nJawab: 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 T(ën/2û) £ c (ën/2û) lg (ën/2û)– Dibuktikan bahwa solusi diatas berlaku untuk n.– 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)

Pada “guess” kadang-kadang solusinya bisa dengan manipulasi aljabar, karena belum pernah diketahui solusi yang mirip.

Contoh:T(n) = 2 T(ëÖnû) + lg nJawab:Misalkan m = lg n « n = 2m

Ön = n1/2 = (2m)1/2 = 2m/2 T(2m) = 2 T(2m/2) + mMisalkan lagi S(m) = T(2m), sehingga rekurensinya menjadi S(m) = 2 S(m/2) + m, Yang mirip dengan T(n) = T(ën/2û) + nJadi solusinya serupa yaitu: S(m) = O(m lg m).Dengan mengubah kembali dari S(m) ke T(n) diperoleh:T(n) = T(2m) = S(m) = O(m lg m) = O(lg n (lg lg n))

2. Metode iterasi (pohon rekursif)Metode iterasi mengkonversi rekurensi ke dalam jumlahan dan kemudian berdasarkan cara untuk bounding summations untuk menyelesaikan rekurensi. Prinsip dari metode iterasi adalah menjabarkan rekurensi sebagai suatu bentuk penjumlahan yang hanya bergantung pada n dan syarat awal.

Contoh: 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 pohon rekursif:Tn = n + T(n)

T(n) = n+2T(n/2)= n log2n, nilai n = (n/2)

n n

n/2 n/2 n

n/4 n/4 n/4 n/4 n

_

nk

n log2n

3. Metode masterMetode 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. Rumus untuk menyelesaikan rekurensi berbentuk:

Andaikan

T (n)=aT ( nb )+ f (n )Di mana, a ≥ 1, b > 1, and f(n) > 0

Case 1: if f(n) = O(nlogb

a -e) for some e > 0, then: T(n) = Q(nlog

ba)

Case 2: if f(n) = Q(nlogb

a), then: T(n) = Q( nlogb

a lgn) Case 3: if f(n) = W(nlog

ba+ε) for some e > 0, and if

af(n/b) ≤ cf(n) for some c < 1 and all sufficiently large n, then: T(n) = Q(f(n))


Contoh:


Algoritma Merge Sort

Documents

Transcript of Algoritma Merge Sort