TUGAS

ALGORITMA DAN STRUKTUR DATA

MERGE SORT
DAN
PENYELESAIAN REKURENSI






Oleh :
Shinta Anisa Putri Yasir
(H12111271)


\
JURUSAN MATEMATIKA
FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM
UNIVERSITAS HASANUDDIN
2012

Merge Sort
Merge sort adalah algoritma yang digunakan untuk menyusun list yang diberikan dengan
cara membagi list yang diberikan menjadi dua bagian yang lebih kecil. Kedua list yang
baru ini kemudian akan disusun secara terpisah. Setelah kedua buah list tersusun, maka
akan dibentuk list baru yang merupakan hasil penggabungan dua buah list 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.


Contoh:
Inputan datanya adalah sebagai berikut:
7 2 6 5


Membagi rangkaian menjadi dua bagian:
7 2

6 5
Kedua bagian tersebut bisa dinamai LeftArr dan RightArr

Membagi LeftArr menjadi dua bagian:
7

2

Membandingkannya kemudian dikombinasikan:
2 7
7 dan 2 kemudian tukar posisi karena 2 < 7

Membagi RightArr menjadi dua bagian:
6

5

Membandingkannya kemudian dikombinasikan:
5 6
6 dan 5 kemudian tukar posisi karena 5 < 6

Membandingkan LeftArr dan RightArr.
2 7 5 6
Kemudian dilakukan proses membandingkan lagi antara angka di LeftArr dengan
RightArr.

Pembandingan biasanya dimulai dari angka terdepan di masing-masing bagian.

Mengkombinasikan LeftArr dengan RightArr.
2 5 6 7
Sehingga menjadi: 2<5<6<7

Contoh program pada PASCAL









Penyelesaian Rekurensi
Ada tiga metode untuk menyelesaikan rekurens, yaitu :
1. Metode Substitusi
- Pertama-tama dibuat suatu guess/tebakan dari bentuk solusinya.
- Gunakan induksi matematika untuk membuktikan bahwa guess itu benar.

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) 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

Selesaikan T(n) = 3 T(n/4) + n








Pohon Rekursi

n n

n/4 n/4 n/4 ()n

T(n/16) T(n/16) T(n/16) T(n/16) T(n/16) T(n/16) T(n/16) T(n/16) T(n/16) (9/16)n

T(n/64) T(n/64) T(n/64) ... ()

n

O(n)

3. Metode Teorema Master

- Bentuk umum : T(n) = a T(n/b) + f(n)
- Theorema: Bila a>1 dan b>1 adalah tetapan dan f(n) adalah suatu fungsi, kemudian
andaikan T(n) didefinisikan pada bilangan bulat positif melalui rekurensi:
( )
( ) ( )
( ) ( ) ( )
( )
( )
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

T(n) = a T(n/b) + f(n), dimana n/b bisa dinyatakan sebagai n/b atau n/b( maka
T(n) dapat dibatasi secara asimptotik, sebagai berikut:
a. Bila f(n) = O(

), dimana c>0 tetapan, maka T(n) = O(

)
b. Bila f(n) = O(

), maka T(n) = O(

)
c. Bila f(n) = O(

) dimana c>0 tetapan, dan bila a.f(n/b) s c.f(n) dengan
konstanta c < 1, dan n cukup besar, maka T(n) = O(f(n)).


Contoh :

- T(n) = 4T(n/2) + n

= n
T(n) = O(

) (a)

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

= n = f(n)
T(n) = O(lg n) (b)

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

()
T(n) = O(

) (c)