RESUME

MERGE SORT DAN REKURSIF

MergeSort adalah algoritma yang berdasarkan strategi divide-and-conquer. Algoritma ini tediri
dari dua bagian utama, yaitu bagian pembagian list menjadi sublist-sublist yang lebih kecil dan
bagian sort (pengurutan) dan merge (penggabungan) pada sublist-sublist tersebut.
1) Divide: membagi masalah menjadi beberapa submasalah yang memiliki kemiripan dengan
masalah semula namun berukuran lebih kecil (idealnya berukuran hampir sama),
2) Conquer: memecahkan (menyelesaikan) masing-masing submasalah (secara
rekursif), dan
3) Combine: mengabungkan solusi masing-masing submasalah sehingga membentuk
solusi masalah semula.
Skema Umum Algoritma Divide and Conquer
procedure DIVIDE_and_CONQUER(input n : integer)
{ Menyelesaikan masalah dengan algoritma D-and-C.
Masukan: masukan yang berukuran n
Keluaran: solusi dari masalah semula }
Deklarasi
r, k : integer
Algoritma
if n s n
0
then {ukuran masalah sudah cukup kecil }
SOLVE upa-masalah yang berukuran n ini
else
Bagi menjadi r upa-masalah, masing-masing berukuran n/k
for masing-masing dari r upa-masalah do
DIVIDE_and_CONQUER(n/k)
endfor
COMBINE solusi dari r upa-masalah menjadi solusi masalah semula }
Endif
Diberikan sebuah array dengan elemen yang terdefinisi adalah sebagai berikut :
[ 6, 19, 2, 45, 33, 12 ]. Cari nilai max dan min dalam array
Algoritma Bila diselesaikan secara divide and conquer
Procedure MinMax(input A : TabelInt, awal, akhir : int; output min, max : int)

min1, min2, max1, max2, k : int;
if ( awal=akhir ) then
min <- awal
max<- akhir
else if (awal = akhir-1) then
min <- Aawal
max <-Aakhir
else
min <- Aakhir
max <- Aawal
else
k <- (awal+akhir) div 2
MinMax ( A, awal, k, min1, max1);
MinMax (A, k+1, akhir, min2, max2);
If ( min1 < min2 ) then
Min <- min1
Else
Min <- min2
If ( max1 > max2 ) then
Max <- max1
Else
Max <- max2

Algoritma Merge Sort
Merge Sort (A,p,r)
Dimana A = lariknya
P= Posisi Indeks 1
r : posisi indeks 2
q(p+r)/2 T(n) = 2
Merge Sort (A,p,r) n
if p < r then 1
q(p+r)/2 (n/2)
Merge-Sort(A, p, q) T(n/2)
Merge-Sort(A, q+1, r) (divide + (n/2)
Merge(A, p, q, r) combine (O) karena linear.
Contoh program merge sort dalam pascal
type INTARRAY = array[1..100000] of integer;

procedure gen_array(var A:INTARRAY; N:integer);
var i:integer;
begin
for i:=1 to N do A[i]:=Random(10*N);
end;

{copia l'array X in Y}
procedure copy_array(var X, Y:INTARRAY; n:integer);
var i:integer;
begin
for i := 0 to N do Y[i] := X[i];
end;

function min(a,b:integer):integer;
begin if a
else min := b;
end;

procedure print_array(var A:INTARRAY; N:integer);
var i:integer;
begin
for i:=1 to min(n, 100) do
begin
write(A[i]:6);
if ((i mod 10)= 0) then writeln;
end;
if (n>100) then writeln('......'); //writeln('array troppo lungo da scrivere');
end;

procedure InsSort(var A: INTARRAY; N: integer);
var i, j, t, indM: integer;
begin {Insertion Sort }
for i := 1 to N-1 do
begin
indM:=i;
for j:=i+1 to N do
if A[j]
t:= A[i];
A[i]:=A[indM];
A[indM] := t;
end;
end;

procedure Merge (var A: INTARRAY; p, q, r: integer);
var i, j, k: integer;
var B: INTARRAY;
begin { Merge }
i := p;
j := q + 1;
k := p;
while ((i <= q) and (j <= r)) do
begin
if (A[i] < A[j])
then begin
B[k] := A[i];
i := i + 1;
end
else begin
B[k] := A[j];
j := j + 1;
end;
k := k + 1;
end;
while (i <= q) do
begin
B[k] := A[i];
k := k + 1;
i := i + 1;
end;
while (j <= r) do
begin
B[k] := A[j];
k := k + 1;
j := j + 1;
end;
for k := p to r do A[k] := B[k];
end;

procedure MergeSort (var A: INTARRAY; p, r: integer);
var q: integer;
begin { MergeSort }
if (p < r) then
begin
q := (p + r) div 2;
MergeSort (A, p, q);
MergeSort (A, q + 1, r);
Merge (A, p, q, r);
end;
end.
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 :




REKURSIF
Rekursif adalah teknik pemecahan masalah yang powerful dan dapat digunakan ketika inti dari
masalah terjadi berulang kali. Tentu saja, tipe dari masalah ini dapat dipecahkan mengunakan
perkataan berulang-ulang (yaitu, menggunakan konstruksi looping seperti for, while dan do-
while).
Rekursi berarti suatu proses yang bisa memanggil dirinya sendiri.
Contoh proses menghitung nilai faktorial
Faktorial (0) = 1 ..................(1)
Faktorial (N) = N * Faktorial (N-1), N > 0 ...........(2)
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.
Persamaan (1) yang tidak bersifat rekursif disebut nilai awal.

Setiap fungsi rekursi paling sedikit memiliki 1 nilai awal, jika tidak, fungsi tersebut tidak bisa
dihitung secara eksplisit.
Rekursi berarti suatu proses yang bisa memanggil dirinya sendiri.
Contoh proses menghitung nilai faktorial
Faktorial (0) = 1 ..................(1)
Faktorial (N) = N * Faktorial (N-1), N > 0 ...........(2)
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.
Persamaan (1) yang tidak bersifat rekursif disebut nilai awal.
Contoh:
Function Fakt (N: integer): integer;
Begin
If N=0 then
Fakt := 1;
Else
Fakt := N * Fakt(N-1)
End;
Berapa untuk N = 4

Metode Penyelesaian Rekurensi:
T (n) = aT (n / b) + f (n), mana 1, b> 1, dan f (n) adalah fungsi yang diberikan, itu
membutuhkan hafalan tiga kasus, tetapi sekali Anda melakukannya, menentukan batas asimtotik
untuk sederhana banyak mudah kambuh.
1. Metode Subsitusi
Metode Substitusi
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) 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
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) + cn
d
dalam hal ini n = b
k
, k = 1, 2, , a > 1, b > 2, dan c dan d adalah bilangan riil > 0, maka







Metode Iterasi/pohon rekursi
Prinsip dari metode iterasi adalah menjabarkan rekurensi sebagai suatu bentuk penjumlahan yang
hanya bergantung pada n dan syarat awal.









Ket:
Nilai T(n) diganti menjadi T(3/4) dan setiap langkahnya ditambah 1/4n sampai
dengan 4 kali pengulangan.

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
_
T(n) adalah

>
=
<
d a
d d
d d
b a n O
b a n n O
b a n O
b
jika ) (
jika ) log (
jika ) (
log



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

nk
n
log2n

Teorema master






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