RESUME REKURSIF by AayUmu

VIEWS: 23 PAGES: 11

									MUCHSINIL HAQ
H12111901
                                      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  n0 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)  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)
   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

                                           O(n d )             jika a  b d
                                          
                              T(n) adalah O ( n d log n)       jika a  b d
                                           O(n log b a )       jika a  b d
                                          


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

         T ( n)      n  3T   n / 4  
                                      
                            
                      n  3  n / 4   3T   n /16  
                                                         
                                            
                      n  3  n / 4   3  n /16   3T   n / 64  
                                                                          
                     n  3  n / 4   9  n /16   27T   n / 64  
                                                                
         T ( n)      n  3n / 4  9n /16  27 n / 64  ...  3log4 n T (1)
                       log 4 n 1    i
                               3
                     n      nlog 4 3          
                          i 0  4 

                     4n  o( n)
      Ket:
                     O ( n)

              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
                                                                                            _
                                                                             nk
                                                                              n log2n


     Teorema master

1.              
     f (n)  O nlogb a      
                    
      T (n)   nlogb a          
2.              
      f (n)   nlogb a   
                    
      T (n)   nlogb a lg n         
3.                           
      f (n)   nlogb a  and af (n / b)  cf (n), for some c  1, n  n0
      T ( n)    f ( n) 

								
To top