Anda di halaman 1dari 15

Algoritma Rekursif

Rekursif
• Rekursif menawarkan teknik penyelesaian persoalan yang di dalamnya
mengandung definisi persoalan itu sendiri.
• Contoh: Faktorial
Faktorial dari bilangan bulat tak-negatif n didefinisikan sebagai berikut:
1 𝑛=0
𝑛! = *
1× 2 ×⋯× 𝑛 −1 ×𝑛 ,𝑛 > 0
Misal:
0! = 1
1! = 1
2! = 1 × 2
3! = 1 × 2 × 3
4! = 1 × 2 × 3 × 4
Algoritma Iteratif
• Proses menghitung faktorial dari bilangan n tak-negatif dinyatakan dalam
algoritma berikut ini:
function Faktorial (input n : integer)  integer
{mengembalikan nilai n!}
DEKLARASI
i : integer
F : integer
ALGORITMA
F  1
i  1
while i < n do
F  F * i
i  i + 1
endwhile
{i > n}
Return F
• Algoritma di atas dinamakan algoritma iteratif karena ia mengerjakan
pengulangan sekumpulan aksi sampai kondisi berhentinya tercapai. Algoritma
iteratif adalah algoritma yang mengerjakan pengulangan aksi selama kondisi
pengulangan masih dipenuhi.
Algoritma Iteratif
• Secara umum, skema algoritma iteratif sebagai berikut:
procedure Iteratif(input x : xType)
{prosedur yang memanipulasi nilai x}
K. Awal: x terdefinisi nilainya}
K.Akhir: sekumpulan aksi yang memanipulasi nilai x yang dilakukan}
DEKLARASI
jika ada
ALGORITMA
Inisialisasi
while Kondisi(x) do
AKSI(x) {kumpulan aksi yang memanipulasi nilai x}
F(x) {aksi yang mengubah nilai x}
endwhile
{not Kondisi (x)}
Terminasi
Algoritma Rekursif
• Faktorial dari n dapat didefinisikan dalam terminologi faktorial juga, seperti
berikut:
0! = 1
1! = 0! × 1
2! = 1! × 2
3! = 2! × 3
4! = 3! × 4
Dari skema di atas, maka untuk n>0 kita melihat bahwa:
𝑛! = 1 × 2 × ⋯ × (𝑛 − 1) × 𝑛
Dengan demikian, dengan menggunakan notasi matematika, maka n!
didefinisikan dalam hubungan rekursif adalah sebagai berikut:
1 𝑛=0
𝑛! = *
1 ×2 ×⋯× 𝑛 −1 ×𝑛 = 𝑛− 1 !× 𝑛 ,𝑛 > 0
atau
1 𝑛=0
𝑛! = *
𝑛−1 !×𝑛 , 𝑛>0
• Kita dapat melihat bahwa dalam proses perhitungan faktorial terdapat definisi
faktorial itu sendiri. Cara ini dinamakan dengan rekursif.
Definisi Rekursif
• Definisi rekursif disusun oleh dua bagian:
– Basis
Bagian yang berisi kasus yang terdefinisi secara eksplisit. Bagian ini juga
sekaligus menghentian rekursif ( dan memberikan sebuah nilai yang
terdefinisi pada fungsi rekursif)
– Rekurens
Bagian ini mendefinisikan objek dalam terminologi dirinya sendiri.
• Tinjau kembali perhitungan n! secara rekursif.
𝑛! = 1 , jika n = 0 basis
𝑛! = 𝑛 × 𝑛 − 1 ! , jika n = 0 rekurens
• Maka 5! Dihitung dengan langkah berikut:
5! = 5 × 4! (1)
4! = 4 × 3! (2)
3! = 3 × 2! (3)
2! = 2 × 1! (4)
1! = 1 × 0! (5)
0! = 1 (6)
Definisi Rekursif
• Maka 5! Dihitung dengan langkah berikut:
5! = 5 × 4! (1)
4! = 4 × 3! (2)
3! = 3 × 2! (3)
2! = 2 × 1! (4)
1! = 1 × 0! (5)
0! = 1 (6)
• Pada baris (6) kita memperoleh nilai yang terdefinisi secara langsung dan
bukan faktorial dari bilanganlainnya. Dengan melakukan runut balik dari baris
(6) ke (1), kita memperoleh nilai pada setiap baris untuk menghitung pada
baris sebelumnya:
0! = 1 (1)
1! = 1 × 0! = 1 (2)
2! = 2 × 1! = 2 (3)
3! = 3 × 2! = 6 (4)
4! = 4 × 3! = 24 (5)
5! = 5 × 4! = 120 (6)
Algoritma Rekursif
• Algoritma rekursif untuk menghitung 𝑛! adalah sebagai berikut:
function Fak(input n : integer)integer
{mengembalikan nilai 𝑛! . Algoritma rekursif
Basis : jika n = 0, maka n!=1
Rekurens : jika n > 0, maka n!= n x (n-1)!
}
DEKLARASI
-

ALGORITMA
if n=0 then
return 1 {basis}
else
return n*Fak(n-1) {rekurens}
endif
Translasi Bahasa C
• Contoh: Faktorial dengan Rekursif
#include<stdio.h>
#include<conio.h>
int Fak(int m);

main()
{
int m;
printf("Masukan sembarang bilangan bulat positif>"); scanf("%d",&m);
printf("\nMelalui perhitungan rekursif, %d!=%d\n", m, Fak(m));
getch();
}

int Fak(int k)
{
if (k==0)
return 1;
else
return k*Fak(k-1);
}
Contoh
• Menghitung 𝑎 × 𝑏 untuk a dan b bilangan bulat positif
𝑎 × 𝑏 = 𝑎 + 𝑎 + ⋯ + 𝑎 (sebanyak b kali)
=𝑎+ 𝑎× 𝑏−1
dengan demikian,
𝑎 , jika 𝑏 = 1,
𝑎 ×𝑏 = *
𝑎+ 𝑎× 𝑏−1 , jika 𝑏 > 1

function Kali(input a, b : integer)integer


{mengembalikan nilai a*b, a dan b > 0
basis : a*b = a jika b=1
rekurens: a*b = a + a*(b-1) jika b>1}

DEKLARASI
-
ALGORITMA
if b=1 then
return a {basis}
else
return a + Kali(a,b-1) {rekurens}
endif
Translasi Bahasa C
#include<stdio.h>
#include<conio.h>

int Kali(int m, int n);

main()
{
int a, b;
printf("Masukan a : "); scanf("%d",&a);
printf("Masukan b : "); scanf("%d",&b);
printf("\nMelalui perhitungan rekursif: %d x %d = %d", a, b, Kali(a,b));
getch();
}

int Kali(int m, int n)


{
if (n==1)
return m;
else
return m + Kali(m,n-1);
}
Contoh
• Perpangkatan 𝑎 𝑛 (𝑎 bilangan bulat dan 𝑛 > 0)
𝑎𝑛 = 𝑎 × 𝑎 × 𝑎 × ⋯ × 𝑎 (sebanyak n kali)
= 𝑎 × 𝑎(𝑛−1) (rekurens)

Secara matematis, fungsi rekursif untuk perpangkatan


1 , jika n = 0,
𝑎𝑛 = *
𝑎 × 𝑎(𝑛−1), jika n > 0
function pangkat(input a, n : integer)integer
{mengembalikan nilai 𝑎 𝑛 , n > 0
basis : 𝑎𝑛, jika n=0
rekurens : 𝑎 × 𝑎 (𝑛−1) jika n>1}
DEKLARASI
-
ALGORITMA
if n=0 then
return 1 {basis}
else
return a*pangkat(a,n-1) {rekurens}
endif
Translasi Bahasa C
#include <stdio.h>
#include <conio.h>

int pangkat(int m, int n);


main ()
{
int m, n;
printf("Masukan bilangan yang akan dipangkatkan: "); scanf("%d", &m);
printf("Masukan bilangan pemangkatnya: "); scanf("%d", &n);
printf("Hasil dari %d pangkat %d adalah %d\n", m, n, pangkat(m, n));
getch();
}

int pangkat(int x, int y)


{
if (y==0)
return 1;
else
return x * pangkat(x, y-1);
}
Contoh
Fungsi Chebysev dirumuskan secara matematis :
1 , 𝑗𝑖𝑘𝑎 𝑛 = 0
𝑇 𝑛, 𝑥 = 𝑥 , 𝑗𝑖𝑘𝑎 𝑛 = 1
2𝑥𝑇 𝑛 − 1, 𝑥 − 𝑇 𝑛 − 2, 𝑥 , 𝑗𝑖𝑘𝑎 𝑛 > 1

ALGORITMA
function T(input n: integer, input x: real)  real

DEKLARASI
-
ALGORITMA
if n=0 then
return 1
else
if n=1 then
return x
else
return 2*x*T(n-1,x) – T(n-2,x)
endif
endif
Translasi Bahasa C
#include<stdio.h>
#include<conio.h>

float T(int n, float x);


main()
{
int n;
float x;
printf("Masukan n : "); scanf("%d",&n);
printf("Masukan x : "); scanf("%f",&x);
printf("\nT(n,x)= %f", T(n,x));
getch();
}

float T(int n, float x)


{
if (n==0)
return 1;
else
if (n==1)
return x;
else
return 2*x*T(n-1,x)-T(n-2,x);