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: