STRUKTUR DATA

TUGAS KE-2

REKURSI

PROGRAM STACK

Tanggal 25 Februari 2009

Oleh:

Junian Triajianto (5108100038)

JURUSAN TEKNIK INFORMATIKA

FAKULTAS TEKNOLOGI INFORMASI

INSTITUT TEKNOLOGI SEPULUH NOPEMBER

2009

REKURSI

Definisi

Rekursi adalah salah satu metode dalam dunia matematika dimana definisi sebuah fungi

mengandung fungsi itu sendiri. Dalam dunia pemrograman, rekursi diimplementasi-kan 

dalam  sebuah  fungsi  yang memanggil dirinya sendiri.

Contoh:

//Program untuk Mencari Faktorial

//Contoh dengan bahasa C

#include <stdio.h>

#include <conio.h>

int faktorial(int n){

if(n==0 || n==1) return 1;

int x = n * faktorial(n-1);

return x;

}

int main(){

int n;

printf("Inputkan N: ");

scanf("%d", &n);

printf("Faktorial dari %d adalah %d",n,faktorial(n));

getch();

return 0;

}

Perbandingan Iterasi dan Rekursi

Persamaan:

Kedua metode perulangan tersebut merupakan teknik looping yang sama-sama memiliki

bagian yang berfungsi sebagai pembatas untuk mengakhiri loop serta memiliki kumpulan

instruksi yang siap untuk diekseskusi berulang-ulang.

Perbedaan:

- Rekursif hanya bisa dilakukan dengan cara membuat fungsi, sedangkan iteratif bisa

berjalan sendiri tanpa menggunakan fungsi dalam program yang terdiri dari prosedur.

- Iteratif membutuhkan instruksi do…while, while, atau for untuk menjalankannya,

sedangkan rekursif tidak memerlukannya.

Perbandingan kelebihan dan kekurangan Iteratif dan Rekursif

Rekursif Iteratif

Kode program biasanya lebih ringkas

dan mudah dipahami

Kode program lebih panjang, untuk beberapa

kasus solusi iteratif lebih sulit diterapkan

Membutuhkan alokasi memori yang

besar

Relatif lebih kecil alokasi memorinya

Tidak cocok ketika kinerja tinggi

diperlukan, karena terjadi overhead

pemanggilan fungsi dalam jumlah

yang relatif besar

Cocok diterapkan ketika kinerja aplikasi

harus diterapkan (hanya ada satu kali

pemanggilan fungsi)

Base case dan recursive case

Base case : suatu bagian pada fungsi rekursi yang dibutuhkan untuk membatasi

rekursi sehingga proses rekursi akan terus berulang selama belum mencapai base case.

Recursive case : bagian pada fungsi rekursi yang mengalami proses perulangan.

PROGRAM STACK

Untuk semua program di bawah ini, digunakan linked list sebagai wadah stack. Semua program diasumsikan bahwa inputnya selalu benar.

Program ke-1: Brackets CheckMerupakan sebuah program untuk mengecek suatu ekspresi infix dengan asumsi bahwa ekspresi dengan operator selain bracket adalah benar. Dengan kata lain yang dicek dalam program ini hanyalah kondisi bracket-nya dengan 3 jenis bracket yaitu (), [], {}.

Inputsebuah ekspresi infix yang akan dicek.

OutputJika ekspresi benar maka akan keluar message BENAR, jika salah akan keluar message SALAH.

Source Code and Documentation (bracket_check.java):import javax.swing.JOptionPane;

public class bracket_check {

/** * main program * @param args */public static void main(String[] args){

bracket_check checker = new bracket_check();String exp;int try_again;

do{exp = JOptionPane.showInputDialog("Masukkan sebuah ek-

spresi infix: ");if(checker.check_expression(exp))

JOptionPane.showMessageDialog(null, "infix:\n" + exp + "\nhasil checking: \nBENAR");

elseJOptionPane.showMessageDialog(null, "infix:\n" +

exp + "\nhasil checking: \nSALAH");try_again = JOptionPane.showConfirmDialog(null, "Wanna

try again?");}while(try_again==0);

}

/** * untuk mengecek kebenaran suatu ekspresi * @param exp * @return true jika ekspresi benar */public boolean check_expression(String exp){ Stack_f expression = new Stack_f(); int i;

for(i=0; i<exp.length(); i++) { if(exp.charAt(i) == '(' || exp.charAt(i) == '[' || ex-

p.charAt(i) == '{') expression.push(exp.charAt(i)); else if(exp.charAt(i) == ')' || exp.charAt(i) == ']' ||

exp.charAt(i) == '}') if(!expression.pop(exp.charAt(i))) return false; } if(!expression.isEmpty()) return false; return true;}

}

//node pada stackclass Node_f{

char data;Node_f next;

/** * Constructor untuk class Node_f sebagai elemen stack * @param new_data */public Node_f(char new_data){

data = new_data;}

}

//stack yg berisi Node_fclass Stack_f{

/** * sebagai node penunjuk top of stack */Node_f top;

/** * memasukkan data baru pada tumpukan teratas * @param new_data */public void push(char new_data){

Node_f new_node = new Node_f(new_data);new_node.next = top;top = new_node;

}

/** * menghapus data bagian atas pada stack * @param exp * @return true jika bisa dihapus */public boolean pop(char exp){

if(isEmpty()) return false;

if(exp == ')' && peek() != '(' || exp == ']' && peek() != '[' || exp == '}' && peek() != '{') return false;

Node_f temp = top.next;top.next = null;top = temp;return true;

}

/** * method untuk menampilkan isi dari tumpukan teratas * @return data bertipe char pada tumpukan teratas */public char peek(){

return top.data;}

/** * method untuk mengecek apakah stack kosong atau tidak * @return true jika kosong */public boolean isEmpty(){

return (top==null);}

}

Screenshots:

Program ke-2: Postfix EvaluationMerupakan sebuah program untuk mengkalkulasikan sebuah ekspresi postfix untuk mendapatkan hasilnya.

Inputsebuah ekspresi postfix yang akan dikalkulasikan

OutputHasil dari perhitungan ekspresi postfix.

Source Code and Documentation (postfix_evaluation.java)

import javax.swing.JOptionPane;

public class postfix_evaluation {

//main programpublic static void main(String[] args) {

String ekspresi;postfix_evaluation evaluator = new postfix_evaluation();int try_again;

do{ekspresi = JOptionPane.showInputDialog("Masukkan se-

buah ekspresi postfix: ");JOptionPane.showMessageDialog(null, "ekspresi:\n" +

ekspresi+"\nhasil:\n" +evaluator.evaluate(ekspresi));try_again = JOptionPane.showConfirmDialog(null, "Wanna

try again?");}while(try_again==0);

}

/** * method untuk mengkalkulasikan sebuah ekspresi postfix * @param ekspresi * @return hasil perhitungan postfix (double) */public double evaluate(String ekspresi){

Stack operand = new Stack(); double temp, opn1, opn2; int i; String tempStr = new String("");

temp = 0;

for(i=0; i<ekspresi.length(); i++) { if(i>0 && !(ekspresi.charAt(i) >= '0' &&

ekspresi.charAt(i) <= '9') && ekspresi.charAt(i-1) >= '0' && ekspre-

si.charAt(i-1) <= '9') { operand.push(tempStr); tempStr = ""; } else if(ekspresi.charAt(i) >= '0' && ekspresi.charAt(i) <=

'9') { tempStr = tempStr + ekspresi.charAt(i); }

//jika ada operator kalkulasikan stack teratas dengan

bawahnya if(is_operator(ekspresi.charAt(i))){ opn1 = Double.valueOf(operand.pop()); opn2 = Double.valueOf(operand.pop()); switch(ekspresi.charAt(i)) { case '+': temp = opn2 + opn1; break;

case '-': temp = opn2 - opn1; break; case '*': temp = opn2 * opn1; break; case '/': temp = opn2 / opn1; break; case '$': temp = Math.pow(opn2, opn1);

break; } operand.push(String.valueOf(temp)); } } return temp;}

/** * mengecek suatu char apakah sebuah operator * @param chr * @return true jika merupakan operator */public boolean is_operator(char chr){

if(chr == '+' || chr == '-' || chr == '*' || chr == '/' || chr == '$'){

return true;}return false;

}

}

class Node{

String data; //data node berupa StringNode next; //next node

/** * constructor class Node sebagai elemen Stack * @param new_data */public Node(String new_data){

data = new_data;}

}

class Stack{

// sebagai node penunjuk top of stackNode top;

/** * cek keadaan apakah stack kosong atau ada isinya * @return true jika stack kosong */public boolean isEmpty(){

return (top == null);}

/**

* menghapus data teratas dalam stack * @return isi dari data yang dihapus */public String pop(){

if(isEmpty()){

System.out.print(" --- Stack is Empty --- ");return ("");

}String tempStr = top.data;Node temp = top.next;top.next = null;top = temp;return (tempStr);

}

/** * menambah data pada tumpukan teratas * @param new_data */public void push(String new_data){

Node new_node = new Node(new_data);new_node.next = top;top = new_node;

}

}

Screenshots:

Program ke-3: Infix to Postfix ConverterMerupakan sebuah program untuk merubah sebuah ekspresi infix menjadi postfix, dengan asumsi bahwa ekspresi yang di-inputkan selalu benar.

InputSebuah ekspresi infix yang akan diubah.

OutputEkspresi postfix yang berasal dari perubahan input

Source Code and Documentation (infix_to_postfix.java):import javax.swing.JOptionPane;

public class infix_to_postfix {

/** * main program * @param args */public static void main(String[] args){

infix_to_postfix converter = new infix_to_postfix();String exp;int try_again;

do{exp = JOptionPane.showInputDialog("Masukkan sebuah ek-

spresi infix: ");JOptionPane.showMessageDialog(null, "infix:\n" + exp +

"\npostfix: \n" + converter.in_to_post(exp));try_again = JOptionPane.showConfirmDialog(null, "Wanna

try again?");}while(try_again==0);

}

/** * mengubah String exp yang merupakan ekspresi infix menjadi post-

fix * @param exp * @return nilai exp yang telah diubah menjadi postfix */public String in_to_post(String exp){

String postfix = new String("");Stack_f stack = new Stack_f(); char sub_str;int i;

for(i=0; i<exp.length(); i++){sub_str = exp.charAt(i);if(sub_str == ')'){

while(stack.peek()!='('){postfix += " " + stack.pop() + " ";

}stack.pop();

}else if(is_operator(sub_str)){if(stack.isEmpty() || hierarchy(stack.peek()) <=

hierarchy(sub_str)){postfix += " ";

}else if(sub_str != '('){postfix += " " + stack.pop() + " ";

}stack.push(sub_str);

}else{

postfix += sub_str;}

}

while(!stack.isEmpty()){postfix += " " + stack.pop() + " ";

}

return postfix;}

/** * untuk mengecek suatu char apakah berupa operator atau bukan * @param opr * @return true jika operator */public boolean is_operator(char opr){

if(opr == '-' || opr == '+' || opr == '*' || opr == '/' || opr == '$' || opr == '('){return true;

}return false;

}

/** * menunjukkan hierarki dari operator * @param opr * @return untuk + dan - bernilai 1, * untuk / dan * bernilai 2, * untuk $ bernilai 3 * selain itu 0 */public int hierarchy(char opr){

if(opr == '+' || opr == '-') return 1;if(opr == '*' || opr == '/') return 2;if(opr == '$') return 3;return 0;

}}

class Node_f{char data;Node_f next;

/** * Constructor untuk class Node_f sebagai elemen stack * @param new_data */public Node_f(char new_data){

data = new_data;}

}

class Stack_f{/** * sebagai node penunjuk top of stack */Node_f top;

/** * memasukkan data baru pada tumpukan teratas * @param new_data */public void push(char new_data){

Node_f new_node = new Node_f(new_data);new_node.next = top;top = new_node;

}

/** * menghapus data pada tumpukan teratas * @return data bertipe char yang dihapus */public char pop(){

char temp_f = top.data;Node_f temp = top.next;top.next = null;top = temp;return temp_f;

}

/** * method untuk menampilkan isi dari tumpukan teratas * @return data bertipe char pada tumpukan teratas */public char peek(){

return top.data;}

/** * method untuk mengecek apakah stack kosong atau tidak * @return true jika kosong */public boolean isEmpty(){

return (top==null);}

}

Screenshots:

Program ke-4: Infix to Prefix ConverterMerupakan sebuah program untuk merubah sebuah ekspresi infix menjadi prefix, dengan asumsi bahwa ekspresi yang di-inputkan selalu benar.

InputSebuah ekspresi infix yang akan diubah.

OutputEkspresi prefix yang berasal dari perubahan input

Source Code and Documentation (infix_to_prefix.java):

import javax.swing.JOptionPane;

public class infix_to_prefix {

/** * main program * @param args */public static void main(String[] args){

infix_to_prefix converter = new infix_to_prefix();String exp;int try_again;

do{exp = JOptionPane.showInputDialog("Masukkan sebuah ek-

spresi infix: ");JOptionPane.showMessageDialog(null, "infix:\n" + exp +

"\nprefix: \n" + converter.in_to_pre(exp));try_again = JOptionPane.showConfirmDialog(null, "Wanna

try again?");}while(try_again==0);

}

/** * mengubah String exp yang merupakan ekspresi infix menjadi pre-

fix * @param exp * @return nilai exp yang telah diubah menjadi prefix */public String in_to_pre(String exp){

String prefix = new String("");Stack_f stack = new Stack_f(); char sub_str;int i;

for(i=exp.length()-1; i>=0; i--){sub_str = exp.charAt(i);if(sub_str == '('){

while(stack.peek() != ')'){prefix = " " + stack.pop() + " " + prefix;

}stack.pop();

}else if(is_operator(sub_str)){

if(stack.isEmpty() || hierarchy(stack.peek()) <= hierarchy(sub_str)){

prefix = " " + prefix;}else if(sub_str != ')'){

prefix = " " + stack.pop() + " " + prefix;}stack.push(sub_str);

}else{prefix = sub_str + prefix;

}}

while(!stack.isEmpty()){prefix = " " + stack.pop() + " " + prefix;

}

return prefix;}

/** * untuk mengecek suatu char apakah berupa operator atau bukan * @param opr * @return true jika operator */public boolean is_operator(char opr){

if(opr == '-' || opr == '+' || opr == '*' || opr == '/' || opr == '$' || opr == ')'){return true;

}return false;

}

/** * menunjukkan hierarki dari operator * @param opr * @return untuk + dan - bernilai 1, * untuk / dan * bernilai 2, * untuk $ bernilai 3 * selain itu 0 */public int hierarchy(char opr){

if(opr == '+' || opr == '-') return 1;if(opr == '*' || opr == '/') return 2;if(opr == '$') return 3;return 0;

}}

class Node_f{char data;Node_f next;

/** * Constructor untuk class Node_f sebagai elemen stack * @param new_data */public Node_f(char new_data){

data = new_data;}

}

class Stack_f{/** * sebagai node penunjuk top of stack */Node_f top;

/** * memasukkan data baru pada tumpukan teratas * @param new_data */public void push(char new_data){

Node_f new_node = new Node_f(new_data);new_node.next = top;top = new_node;

}

/** * menghapus data pada tumpukan teratas * @return data bertipe char yang dihapus */public char pop(){

char temp_f = top.data;Node_f temp = top.next;top.next = null;top = temp;return temp_f;

}

/** * method untuk menampilkan isi dari tumpukan teratas * @return data bertipe char pada tumpukan teratas */public char peek(){

return top.data;}

/** * method untuk mengecek apakah stack kosong atau tidak * @return true jika kosong */public boolean isEmpty(){

return (top==null);}

}

Screenshots: