Handout Struktur Data

REKURSI

Pengertian Rekursi

Rekursi (recursion) adalah proses dari suatu subprogram (dapat berupa fungsi atau
prosedur) yang memanggil dirinya sendiri, sehingga dapat terjadi perulangan (looping).
Rekursi merupakan teknik pemrograman yang penting, dan beberapa bahasa pemrograman
modern mendukung keberadaan proses rekursi ini, termasuk bahasa pemrograman pascal.
Contoh berikut ini merupakan proses rekursi yang tidak pernah berakhir, karena tidak
mengandung kondisi pengakhiran rekursi tersebut. Untuk mengakhiri proses rekursi ini,
harus ditekan tombol Ctrl-C atau Ctrl-Break.

//Program rekursi yang tidak berakhir

class Rekursif
{
public static void main(String[] args)
{
doTowers();
}
public static void doTowers()
{
System.out.print("Langkah");
doTowers();
}
}

Kondisi pengakhiran rekursi dapat dilakukan dengan menggunakan statemen

penyeleksian kondisi. Rekursi akan dihentikan bila kondisi telah memenuhi syarat.

Contoh:
Proses rekursi ini akan dilakukan sebanyak 5 kali, yaitu dengan menyeleksi kondisi dari
variable i sampai dengan bernilai < 5 sebagai berikut:

1 Syamsuddin, ST,
ST, M.Kom
Handout Struktur Data

//Program rekursi dengan kondisi terminasi

class Rekursif1
{
static int akhir;
public static void main(String[] args)
{
akhir=0;
rekursif();
}

public static void rekursif()

{
if (akhir < 5)
{
System.out.println("java");
akhir=akhir+1;
rekursif();
}
}
}

Contoh:
Prosedur deret ini digunakan untuk menampilkan suatu deret bilangan bulat N dari 0 sampai
dengan 10 sebagai berikut:

//Program rekursi deret dalam bentuk prosedur

class Rekursif2
{
static int N;
public static void main(String[] args)
{
N=0;
rekursif(N);
}

public static void rekursif(int N)

{
System.out.print(N +" ");
if (N < 10)
{
rekursif(N+1);
}
}
}

2 Syamsuddin, ST,
ST, M.Kom
Handout Struktur Data

Contoh paling sederhana dari proses rekursi adalah proses menghitung nilai faktorial
dari bilangan bulat positif dan mencari deret Fibonaci dari suatu bilangan bulat.

Faktorial

N factorial adalah 1 x 2 x 3 x … x N (dengan asumsi N > 3) dan dapat dirumuskan

dengan:
N! = N * (N-1) * (N-2) * … * 1
Perumusan ini dapat didefinisikan secara rekursi sebagai berikut:
N! = N * (N-1)!
Misalnya akan dihitung sebesar 5!, maka dapat dilakukan secara rekursi dengan cara:
5! = 5 * 4!
Secara rekursi nilai 4! Dapat dihitung kembali sebesar 4 * 3!, sehingga 5! Menjadi:
5! = 5 * 4 * 3!
Secara rekursi nilai 3! Adalah 3 * 2!, sehingga nilai 5! Menjadi:
5! = 5 * 4 * 3 * 2!
Secara rekursi nilai nilai dari 2! Adalah 2 * 1, sehingga akhirnya nilai 5! Adalah sebesar:
5! = 5 * 4 * 3 * 2 *1 = 120
Dari uraian ini, maka dapat dibuat suatu prosedur untuk menghitung nilai N! secara rekursi
sebagai berikut:

//Program factorial
menghitung N! dengan prosedur secara rekursi}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class RekursifFaktorial {

public static void main(String[] args) {
System.out.print("Masukkan bilangan yang akan di-FAKTORIAL-kan : ");
final int bilangan = inputData();
System.out.print("Faktorial dari " + bilangan
+ " adalah " + faktorial(bilangan)+ ".Mudah kan?");}
private static int faktorial(int bilangan) {
if (bilangan <= 0)
return 1;
else
bilangan = bilangan * faktorial(bilangan - 1);
return bilangan;
}

3 Syamsuddin, ST,
ST, M.Kom
Handout Struktur Data

private static int inputData() {

BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in));
String angkaInput = null;
try {
angkaInput = bfr.readLine();
} catch (IOException e) {
e.printStackTrace();}
int Data = Integer.valueOf(angkaInput).intValue();
return Data;
}
}

Proses rekursi harus mempunyai kondisi terminasi (akhir dari proses rekursi). Kondisi
terminasi pada program factorial ini terletak pada penyeleksian kondisi bila nilai N lebih
kecil atau sama dengan 1 sebagai berikut:

If N <= 1 Then
Hasil := 1

Nilai dari N ini tidak akan bernilai 0, karena setelah nilai N menjadi 1, proses rekursi
akan diakhiri, kecuali bila akan dihitung sebesar 0!. Nilai 0! Adalah 1.
Dengan demikian proses rekursi ini dapat didefenisikan:

N! = 1 ------------------------------------------------- untuk N <= 1

N! = N * (N-1)! -------------------------------------- untuk N > 1

4 Syamsuddin, ST,
ST, M.Kom
Handout Struktur Data

Perkalian dua bilangan bulat positip

Contoh lain dari proses rekursi adalah perkalian dari dua bilangan bulat positip. Hasil
perkalian A * B untuk A dan B yang merupakan nilai bulat positip dapat di definisikan
sebagai A ditambah dengan nilainya sendiri sebanyak B kali.
Proses rekursi ini selanjutnya dapat didefinisikan:

A * B = A -------------------------------------------- untuk B = 1
A * B = A + A * (B-1) ----------------------------- untuk B > 1

Misalnya untuk menghitung 5 * 3 dengan cara rekursi ini, maka dapat dihitung terlebih
dahulu 5 * 2 dan ditambahkan dengan 5 dan dapat ditulis:

5 * 3 = 5 + 5 * (2)
5 * 3 = 5 + 5 + 5 * (1)
5 * 3 = 5 + 5 + 5 = 15

Pada perhitungan secara rekursi ini, kondisi terminasi rekursi tampak pada nilai B yang
sudah bernilai 1. Selanjutnya program secara rekursi dapat dituliskan:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Rekursifkali

{ static int a,b;
public static void main(String[] args)
{
System.out.print("Masukkan bilangan 1 : ");
final int a = inputData();
System.out.print("Masukkan bilangan 2 : ");
final int b = inputData();
System.out.println(a +" x "+ b +" = "+ kali(a,b));
}
private static int kali(int a, int b)
{
if (b == 1)
return a;
else
b = a + kali(a,b-1);
return b;
}

5 Syamsuddin, ST,
ST, M.Kom
Handout Struktur Data

private static int inputData() {

BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in));
String angkaInput = null;
try
{
angkaInput = bfr.readLine();
} catch (IOException e)
{
e.printStackTrace();
}
int Data = Integer.valueOf(angkaInput).intValue();
return Data;
}
}

Kelemahan Rekursi

Untuk kasus-kasus tertentu, rekursi dapat mempunyai kelemahan, yaitu suatu proses
yang sudah dilakukan akan diproses ulang kembali, sehingga akan membuat proses menjadi
lama. Ambillah suatu contoh yang cukup terkenal, yaitu deret Fibonacci (Fibonacci
sequence) yang mempunyai suku-suku bilangan integer sebagai berikut:

1, 1, 2, 3, 5, 8, 13, 21, …

Dalam deret ini, nilai-nilai tiap suku adalah hasil penjumlahan dari nilai dua suku
sebelumnya. Misalnya nilai suku ke 3 adalah hasil dari nilai suku pertama ditambah dengan
nilai suku kedua ( 1 + 1 = 2). Nilai suku ke 4 adalah nilai suku ke 2 ditambah nilai suku ke 3
(1 + 2 = 3) dan seterusnya. Deret Fibonacci ini selanjutnya dapat didefinisikan secara rekursi
sebagai berikut:
Fibonacci (N) = N -------------------------------------------------------- untuk N < 2
Fibonacci (N) = Fibonacci (N-2) + Fibonacci (N-1) ----------------- untuk N >= 2

Program rekursi dalam bentuk fungsi untuk menghitung nilai suatu suku dalam deret
Fibonacci ini dapat berupa:

6 Syamsuddin, ST,
ST, M.Kom
Handout Struktur Data

//Program Fibonacci menghitung suku ke N

//Dari deret Fibonacci secara rekursi

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class fibonacci {

static int a;
public static void main(String[] args) {
System.out.print("Suku ke berapa ? ");
final int a = inputData();
System.out.println("Nilai suku ke "+ a +" adalah "+ fibonacci(a));
}
private static int fibonacci(int a) {
if (a<2)
return a;
else
a = fibonacci(a-2) + fibonacci(a-1);
return a;
}
private static int inputData() {
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in));
String angkaInput = null;
try {
angkaInput = bfr.readLine();
} catch (IOException e) {
e.printStackTrace();
}
int Data = Integer.valueOf(angkaInput).intValue();
return Data;
}
}

Dari proses rekursi ini, untuk menghitung suku ke 6 dapat dilakukan dengan tahapan:
Fibonacci(6) = Fibonacci(4)+Fibonacci(5)
= Fibonacci(2)+Fibonacci(3)+Fibonacci(5)
= Fibonacci(0)+Fibonacci(1)+Fibonacci(3)+Fibonacci(5)
= 0+1+Fibonacci(1)+Fibonacci(2)+Fibonacci(5)
= 1+1+Fibonacci(0)+Fibonacci(1)+Fibonacci(5)
= 2+0+1+Fibonacci(3)+Fibonacci(4)
= 3+Fibonacci(1)+Fibonacci(2)+Fibonacci(4)
= 3+1+Fibonacci(0)+Fibonacci(1)+Fibonacci(4)
= 4+0+1+Fibonacci(2)+Fibonacci(3)
= 5+Fibonacci(0)+Fibonacci(1)+Fibonacci(3)
= 5+0+1+Fibonacci(1)+Fibonacci(2)
= 6+1+Fibonacci(0)+Fibonacci(1)
= 7+0+1
= 8

7 Syamsuddin, ST,
ST, M.Kom
Handout Struktur Data

Tampak bahwa tiap-tiap proses rekursi ini akan memanggil dirinya sendiri sebanyak
2 kali. Misalnya untuk menghitung Fibonacci(6) ini, maka fungsi Fibonacci akan dipanggil
sebanyak 2 kali, yaitu untuk Fibonacci(4) dan Fibonacci(5). Untuk menghitung Fibonacci(5),
maka Fibonacci(3) dan Fibonacci(4) harus dihitung lagi, padahal Fibonacci(4) sudah pernah
dihitung, sehingga terjadi perhitungan yang redundan. Akibatnya proses menjadi lama. Pada
contoh diatas, untuk menghitung Fibonacci(6), maka Fibonacci(3) dihitung sebanyak 3 kali.
Hal ini akan lebih efisien bila nilai Fibonacci(3) diingat terus setelah dihitung dan digunakan
lagi setiap saat dibutuhkan. Demikian juga setelah menghitung Fibonacci(4), nilai ini diingat
terus untuk digunakan selanjutnya bila diperlukan. Cara seperti ini tidak dapat dilakukan
pada rekursi, tetapi dapat dilakukan dengan cara iterasi. Bandingkan dengan program itersi
berikut ini yang menggunakan statemen For yang lebih efisien dibandingkan dengan cara
rekursi:

8 Syamsuddin, ST,
ST, M.Kom
Handout Struktur Data

//Program Fibonacci menghitung suku ke N

//Dari deret Fibonacci secara iterasi

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class fibonacci1 {

static int a;
public static void main(String[] args) {
System.out.print("Suku ke berapa ? ");
final int a = inputData();
System.out.println("Nilai suku ke "+ a +" adalah "+
fibonacci1(a));
}
static int batasbawah,batasatas,x,i;
private static int fibonacci1(int a) {

if (a<2)
return a;
else
{
batasbawah = 0;
batasatas = 1;
for (i=2;i<=a;i++)
{
x = batasbawah;
batasbawah=batasatas;
batasatas=x+batasbawah;
}
return batasatas;
}
//return a;
}

private static int inputData() {

BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in));
String angkaInput = null;
try {
angkaInput = bfr.readLine();
} catch (IOException e) {
e.printStackTrace();
}
int Data = Integer.valueOf(angkaInput).intValue();
return Data;
}
}

9 Syamsuddin, ST,
ST, M.Kom
Handout Struktur Data

Dengan cara iterasi ini, untuk menghitung nilai Fibonacci(8) dapat dilakukan dengan cara:

BatasBawah = 0
BatasAtas = 1

Untuk I = 2 (suku ke 2):

X = 0
BatasBawah = 1
BatasAtas = 0 + 1 = 1
Untuk I = 3 (suku ke 3):
X = 1
BatasBawah = 1
BatasAtas = 1 + 1 = 2
Untuk I = 4 (suku ke 4):
X = 1
BatasBawah = 2
BatasAtas = 1 + 2 = 3
Untuk I = 5 (suku ke 5):
X = 2
BatasBawah = 3
BatasAtas = 2 + 3 = 5
Untuk I = 6 (suku ke 6):
X = 3
BatasBawah = 5
BatasAtas = 3 + 5 = 8
Untuk I = 7 (suku ke 7):
X = 5
BatasBawah = 8
BatasAtas = 5 + 8 = 13
Untuk I = 8 (suku ke 8):
X = 8
BatasBawah = 13
BatasAtas = 8 + 13 = 21

Hasil akhirnya Fibonacci(8) adalah 21

10 Syamsuddin, ST,
ST, M.Kom
Handout Struktur Data

Latihan
1. Buatlah program faktorial secara rekursi dengan output sebagai berikut:

PROGRAM FAKTORIAL
=================

Inputkan bilangan yang ingin difaktorialkan : 5

5 Faktorial = 5 * 4 * 3 * 2 * 1 = 120

2. Buatlah program kombinasi menggunakan prosedur factorial secara rekursi dengan

rumus kombinasi sebagai berikut:

N!
C =
(N − R )! * R !

Keterangan : N = Banyaknya data yang akan dikombinasikan

R = Banyaknya kombinasi
C = Jumlah kombinasi yang terjadi

Dengan contoh output berikut ini:

PROGRAM KOMBINASI
=================

Banyaknya data : 5
Banyaknya kombinasi : 3

Jumlah kombinasi yang terjadi : 10

3. Buatlah program penjabaran rumus secara rekursi dengan rumus : N! + M Z

dengan output yang diinginkan berikut ini:

PROGRAM PENJABARAN RUMUS

========================
N! + M Pangkat Z
=================
Inputkan Nilai N : 6
Inputkan Nilai M : 5
Inputkan Nilai Z : 3

Hasilnya adalah : 845

11 Syamsuddin, ST,
ST, M.Kom