PRAKTIKUM 1

PERCABANGAN DAN PENGULANGAN

Dasar Teori
Percabangan
Percabangan adalah pemilihan statemen pada kondisi minimal dua pilihan
maksialnya tak terhingga pilihan, yang akan dieksekusi selanjutnya di mana
pemilihan tersebut didasarkan atas kondisi tertentu. Dalam bahasa Java terdapat dua
buah jenis percabangan, yaitu struktur if dan struktur switch.
If di gunakan dalam satu kondisi saja. Jika pernyataan benar
(terpenuhi) maka akan dijalankan, jika salah (tidak terpenuhi), maka akan di abaikan.
If Else, printah ini digunakan untuk lebih dari satu kondisi. Switch, perintah ini
merupakan alternative pengganti dari If, if else dan else. Switch, kondisinya hanya
dinyatakan dengan bilangan bulatatau karekter/string.

Pengulangan
Selanjutnya adalah pengulangan, pengulangan atau panggilan akrabnya
looping merupakan salah satu cara untuk mengulangi beberapa bentuk nilai yang di
ulang berkali-kali sesuai dengan batas yang kita tentukan. Pengulan dapat
memudahkan kita dalam pemrograman juga mempersingkat pengodean, adanya
pengulan, kita tidak perlu memasukan nilai satu persatu. Pengulan ini memiliki
beberapa jenis mulai dari for, while, juga do while.
For untuk mengulangi proses yang sudah di ketahui jumlahnya. While untuk
mengulangi proses yang belum di ketahui jumlahnya, pengecakan kondisi di awalkan
jika bernilai true maka akan di kerjakan jika false maka akan di hentikan. Do While
untuk mengulangi proses yang belum di ketahui jumlahnya, bedanya dengan while,
do while akan mengerjakan terlebih dahulu lalu mengcek kondisi.

• read (nama, nilai)

if nilai >= 60 then
keterangan = ‘lulus’
else
keterangan = ‘tidak lulus’
write(nama, keterangan)

import java.util.Scanner;
public class IfElse {
public static void main(String args[]){
Scanner in=new Scanner(System.in);
System.out.println("Nilai Mu\n=========\nInput Nama\t:");
 String nama=in.nextLine();
System.out.println("Input Nilai\t:");
int nilai=in.nextInt();
if(nilai>=60){
System.out.println("Nama\t: "+nama);
System.out.print("Keterangan\t: Anda dinyatakan Lulus");
}
else{
System.out.println("Nama\t: "+nama);
System.out.print("Keterangan\t: Maaf Anda Belum Lulus");
}
}
}

• Deklarasi
K : integer {pencacah pengulangan}
Deskripsi
K ← 1 {inisialisasi}
While k ≤ 10 do
Write (‘HALO’)
K ←K+1
Endwhile
{kondisi berhenti : k > 10}.

import java.util.Scanner;
public class While{
public static void main (String [] args){
Scanner in = new Scanner (System.in);
int K;
K=1;
while(K<=10){
System.out.println("HALO");
K+=1;
}
}
}
import java.util.Scanner;
public class Modulus {
public static void main(String args[]){
Scanner in=new Scanner(System.in);
System.out.println("Modulus");
System.out.println("Input Bilangan\t: ");
int n=in.nextInt();
if(n%2==1){
System.out.println(n+"%2 Merupakan bilangan Ganjil");
}
else{
System.out.println(n+"%2 Merupakan bilangan Genap");
}

}
}
import java.util.Scanner;
public class PerhitunganDuaBilangan {
public static void main(String args[]){
Scanner in=new Scanner(System.in);
System.out.println("Modulus");
System.out.println("Input x\t: ");
int x=in.nextInt();
System.out.println("Input y\t: ");
int y=in.nextInt();
int P=x+y;
if(P>=0){
int q=x*y;
System.out.println("Karena P>=0, maka hasil dari "+x+" * "+y+" adalah : "+q); }
else{
int q=x/y;
System.out.println("Karena P<=0, maka hasil dari "+x+" / "+y+" adalah : "+q);
}}
 PRAKTIKUM 2
RECORD
Recor adalah suatu struktur data yang terdiri dari kumpulan elemen-elemen dat
yang di gabungkan menjadi suatu kesatuan, masing-masing elemen data tersebut
disebut dengan field. Setiap field boleh berbeda type datanya. Tetapi record ini
hanya ada di bahasa pemrograman Pascal. Kalau dalam bahasa java iktilap (berbeda
pendapat), ada yang menyebut kan di java juga terdapat record, dan ada juga yang
menyebutkan bahwa di java tidak ada record.
Ini merupakan contoh Recor dalam Java :
class Tanggal { int hari,bulan,tahun; }
class record{ public static void main(String[]args){
/*sesuaikan dengan nama class-nya, termasuk besar kecilnya huruf*/
Tanggal t1 = new Tanggal();
t1.hari = 2;
t1.bulan = 10;
t1.tahun = 2013; /*data yang lain*/
Tanggal t2 = new Tanggal();
t2.hari = 7;
t2.bulan = 5;
t2.tahun = 2016;
System.out.println("waktu sebelumnya : "+t1.hari+"-"+t1.bulan+"-"+t1.tahun);
System.out.println("sekarang : "+t2.hari+"-"+t2.bulan+"-"+t2.tahun); }
}
Buatlah Program Java untuk menentukan suatu tahun kabisat atau bukan?
Input: Tahun
Ouput: Tahun Kabisat/ Bukan Tahun Kabisat
Buatlah Program Java untuk untuk menghitung akar-akar persamaan kuadrat
dengan rumus:
D=B*B-4*A*C
Jika D < 0 maka didapat akar imajiner
Jika D = 0 maka X1 = X2 yang didapat dari D = -B / (2 * A)
Jika D > 0 maka ada dua akar X 1  B  D / 2 * A dan X 2  B  D / 2 * A
Buat Program Java untuk memasukan suhu dalam celcius (t) dengan ketentuan sbb:
jika dimasukan t<0 maka padat, 0<=t<=100 cair, t>100 gas.

import java.util.Scanner;
public class PraktikumDua {
public static void main(String args[]){
Scanner in=new Scanner(System.in);
System.out.println("Menu Tugas Praktikum 2");
System.out.println("1. Tahun Kabisat\n2. Menghitung Akar Persamaan
Kuadrat\n3. Suhu Dalam Celcius");
int pil=in.nextInt();
switch(pil){
case 1:
System.out.println("\t\t\tProgram Tahun Kabisat");
System.out.print("Masukan Tahun\t: ");
 int th=in.nextInt();
if(th%400==0||th%4==0){
System.out.println(th+" Merupakan Tahun Kabisat");
}
else{
System.out.println(th+" Bukanlah Tahun Kabisat");
}
break;
case 2:
System.out.print("\t\tMenghitung Akar Persamaan Kuadrat");
double a,b,c,D,x1,x2;
System.out.print("Masukan Nilai a\t: ");
a=in.nextDouble();
System.out.print("Masukan Nilai b\t: ");
b=in.nextDouble();
System.out.print("Masukan Nilai c\t: ");
c=in.nextDouble();
D =(b*b) - (4*a*c);
x1 = (-b+Math.sqrt(D))/2*a;
x2 = (-b-Math.sqrt(D))/2*a;
if(D<0){
System.out.println(D+" Merupakan Akar Imaginer");
}
else{
System.out.println("Akar Pertama\t"+x1+"\nAkar Kedua\t"+x2);
}
break;
case 3:
System.out.println("Golongan Suhu Celcius");
System.out.print("Masukan Suhu Celcius\t");
double t=in.nextDouble();
if (t<0){
System.out.print(t+" : Padat");
}
else if(t>100){
System.out.print(t+" : Gas");
}
else if(t<=100 || t>=0){
System.out.print(t+" : Cair");
}
}
}
}
 PRAKTIKUM 3
CASTING & KONVERSI
Casting adalah perubahan tipe data ke tipe data lainnya dengan memperhatikan
ukuran juga kapasitas di setiap tipe data. Beberapa casting di sebut juga konversi.
Proses konversi disarankan dari tipe data kecil ke besar. Alasannya Karena jika
konversi dilakukan dari ukuran besar ke kecil ada kemungkinan akan
menghilangkan beberapa data karena kapasitas yang tidak mencukupi.
Contoh programnya :
public class BelajarCasting {
public static void main(String[] args) {
int nilai = 9; //memasukant nilai untuk tipe data integer
String duapuluh ="20"; //memasukan nilai untuk tipe data string
int ubah = Integer.parseInt(duapuluh); //merubah tipe data integer ke
string
System.out.println("Tanggal Lahir Saya = " +(nilai + ubah)); //menampilkan
hasil ke layar
}
}

public class MainClass{

public static void main(String[] args) {
int i=200;
long l=i;
float f=l;
System.out.println("Int value dari :"+i);
System.out.println("Long value dari :"+l);
System.out.println("Float value dari :"+f);
}
}

public class MainClass1{

public static void main(String[] args) {
double d=120.04;
long l=(long) d;
int i=(int)l;
System.out.println("Double value dari :"+d);
System.out.println("Long value dari :"+l);
System.out.println("Int value dari :"+i);
}
}

public class LatihanKonversi{

public static void main(String[]args){
int nilai= 60;
long angka;
angka=nilai; //Konversi dari integer ke long
System.out.println(angka);
}
}

public class LatihanCasting{

public static void main(String[]args){
int nilai= 60;
String hasilCast = String.valueOf(nilai);//Casting dari int ke String
System.out.println(hasilCast);
}
}

public class LatihanCasting{

public static void main(String[]args){
String nilai= “60”;
int hasilCast = Integer.valueOf(nilai); // Casting dati String ke int
System.out.println(hasilCast);
}
}

public class DemoKonversi {

public static void main(String[] args) {
int a = 257;
double d = 274.5678;
// typecasting dari tipe int ke tipe byte
byte b;
b = (byte) a;
System.out.println("Typecasting dari tipe int ke tipe byte");
System.out.println("int: " + a);
System.out.println("byte: " + b);

// typecasting dari tipe double ke tipe int

int x;
x = (int) d;
System.out.println("\nTypecasting dari tipe double " +
"ke tipe int");
System.out.println("double: " + d);
System.out.println("int: " + x);
 PRAKTIKUM 4
OBJECT & CLASS
Object dan kelas dalam bahasa pemrograman java adalah bahasa berorientasi
object. Sebagai bahasa yang memiliki fitur object oriented, java mendukung konsep
dasar polymorphism, inheritance, encapsulation, abstraction, classes, object, intence,
method juga message parsing.

Object adalah intence dari class secara umum mempresentasikan sebuah

object, sebuah intence adalah representasi nyata dari class itu sendiri. Contohnya dari
class KitabKuning kida dapat membuat membuat object Alfiyah Ibnu Malik, Alfiyah
Ibnu Mu’ti, Alfiyah Maemuniyah, Safinatunnajah, Sulamutaufek, Nadzom Maqsud dan
lainya.

Sedangkan class merupakan suatu Blueprint atau Cetakan untuk

menciptakan suatu instant dari object. Contohnya : Class Person, Tree, Fruit, Vehicle
dan lainnya.

Berikut merupan Contoh dari Class juga Object :

class Number {
public static void main(String[] args) {
Double n1 = -1.0, n2 = 4.5, n3 = -5.3, largestNumber;
if (n1 >= n2) {
if (n1 >= n3) {
largestNumber = n1;
} else {
largestNumber = n3;
}
} else {
if (n2 >= n3) {
largestNumber = n2;
} else {
largestNumber = n3;
}
}
System.out.println("Largest number is " + largestNumber);
}
}

public class NestedIf {

public static void main(String[] args){
double uang = 10000;
double barang = 15000;
if(uang >= barang){
if (uang > barang * 6)
System.out.println("Anda Bisa Membeli 6 Kali Barang");
else if (uang >= barang * 5)
System.out.println("Hanya Bisa Membeli 5 Barang Saja");
 else if (uang >= barang * 4)
System.out.println("Hanya Bisa Membeli 4 Barang Saja");
else if (uang >= barang * 3)
System.out.println("Hanya Bisa Membeli 3 Barang Saja");
else if (uang >= barang * 2)
System.out.println("Hanya Bisa Membeli 2 Barang Saja");
else if (uang >= barang)
System.out.println("Hanya Bisa Membeli 1 Barang Saja");
} else
System.out.println("Uang Anda tidak cukup");
System.out.println("Alhamdulillah");
}
}

import java.util.Scanner;
public class Evaluasi {
public void prosesHasilUjian(){
Scanner input = new Scanner(System.in);
//Inisialisasi
int jumlahLulus = 0;
int jumlahGagal = 0;
int counterSiswa = 1;
int hasil;
//while loop
while(counterSiswa <= 8){
System.out.print("Masukkan hasil ujian (1 = lulus atau 2 = gagal): ");
hasil = input.nextInt();
//if...else yang bersarang di while loop
if(hasil == 1){
jumlahLulus = jumlahLulus + 1;
}
else {
jumlahGagal = jumlahGagal + 1;
}
counterSiswa = counterSiswa + 1;
}
System.out.printf("Lulus : %d\nGagal : %d\n", jumlahLulus, jumlahGagal);
if (jumlahLulus > 4){
System.out.print("Kursus telah berhasil!");
}
else{
System.out.print("Kursus tidak berhasil!");
}
}
}

class Overload
{
void demo (int a)
{
System.out.println ("a: " + a);
}
void demo (int a, int b)
 {
System.out.println ("a and b: " + a + "," + b);
}
double demo(double a) {
System.out.println("double a: " + a);
return a*a;
}
}
class MethodOverloading
{
public static void main (String args [])
{
Overload Obj = new Overload();
double result;
Obj .demo(10);
Obj .demo(10, 20);
result = Obj .demo(5.5);
System.out.println("O/P : " + result);
}
}

public class Animal{ class Horse extends Animal{

public void sound(){ @Override
System.out.println(“Binatang public void sound(){
Bersuara"); System.out.println("Meringkik");
} }
} public static void main(String args[]){
Animal obj = new Horse();
obj.sound();
}
}
public class Cat extends Animal{
@Override
public void sound(){
System.out.println("Meong");
}
public static void main(String args[]){
Animal obj = new Cat();
obj.sound();
}
}

class CetakDataTipe {
// membuat method dengan nama sama tapi berbeda tipe data
public void CetakData(String Cetak) {
System.out.println(Cetak);
}
public void CetakData(int Cetak) {
System.out.println(Cetak);
}
 public void CetakData(double Cetak) {
System.out.println(Cetak);
}
public void CetakData(char Cetak) {
System.out.println(Cetak);
}
}

public class Polymorphism {

public static void main(String[] args) {
CetakDataTipe data = new CetakDataTipe();
System.out.print("Cetak Data Tipe String : ");
data.CetakData("Sumatra");
System.out.print("Cetak Data Tipe Integer : ");
data.CetakData(1989);
System.out.print("Cetak Data Tipe Double : ");
data.CetakData(16.5 / 2);
System.out.print("Cetak Data Tipe Char : ");
data.CetakData('N');
}
}

import java.util.Scanner;
public class NilaiMhs{
public static void main (String [] args){
 Scanner in = new Scanner (System.in);
System.out.print("Input Nilaimu\t:");
double nAkhir=in.nextDouble();
if (nAkhir >=85 && nAkhir<=100){
System.out.print("Grade Mu Adalah\t:A");
}
else if (nAkhir >=75 && nAkhir<=84){
System.out.print("Grade Mu Adalah\t:AB");
}
else if (nAkhir >=65 && nAkhir<=74){
System.out.print("Grade Mu Adalah\t:B");
}
else if (nAkhir >=50 && nAkhir<=64){
System.out.print("Grade Mu Adalah\t:BC");
}
else if (nAkhir >=35 && nAkhir<=49){
System.out.print("Grade Mu Adalah\t:C");
}
else if (nAkhir >=20 && nAkhir<=34){
System.out.print("Grade Mu Adalah\t:D");
}
else if (nAkhir >=0 && nAkhir<=19){
System.out.print("Grade Mu Adalah\t:E");
}
}
}
 PRAKTIKUM 5
REKURSIF
Rekursif adalah suatu proses atau prosedur dari fungsi yang memanggil dirinya
sendiri secara berulang-ulang. Karena proses dalam Rekursif ini terjadi secara
berulang-ulang maka harus ada kondisi yang membatasi pengulangan persebut, jika
tidak maka proses tidak akan pernah berhenti sampai memori yang digunakan
untuk menampung proses tersebut tidak dapat menampung lagi/penuh. Kelebihan
Fungsi Rekursif adalah program menjadi lebih singkat. Pada beberapa kasus, lebih
mudah menggunakan fungsi rekursif, contohnya: pangkat, factorial, dan fibonacci,
dan beberapa proses deret lainnya. Fungsi rekursif lebih efisien dan cepat
dibandingkan proses secara iteratif. Kekurangan Fungsi Rekursif adalah memakan
memori lebih besar, karena setiap bagian dari dirinya dipanggil, akan
membutuhkan sejumlah ruang memori untuk penyimpanan. Rekursif sering kali
tidak bisa berhenti sehingga memori akan terpakai habis dan program bisa hang.
Contoh penerapan Rekursif :
1. Faktorial dari bilangan bulat positif n didefinisikan sebagai berikut.
n! = n x (n-1)! Untuk n > 1
0! = 1 Untuk n = 0 atau n = 1
secara pemrograman dapat ditulis sebagai
Faktorial(0) = 1 (1)
Faktorial(N) = N*Faktorial(N-1) (2)
Persamaan (2) di atas adalah contoh hubungan rekurens (recurrence relation), yang
berarti bahwa nilai suatu fungsi dengan argumen tertentu bisa dihitung dari fungsi
yang sama dengan argumen yang lebih kecil. Persamaan (1) tidak bersifat rekursif,
disebut nilai awal atau basis. Setiap fungsi rekursif paling sedikit mempunyai satu
nilai awal, jika tidak fungsi tersebut tidak bisa dihitung secara eksplisit.

Contoh Program Rekursif :

public class Main {
public static void main(String[] args) {
cetakAngka(1);
}
static void cetakAngka(int angka) {
if (angka <= 10) {
System.out.print(angka + " ");
cetakAngka(++angka);
}
}
}

public class Main2 {

public static void main(String[] args) {
cetakSegitigaSiku(1, 1, 5);
}
 static void cetakSegitigaSiku(int row, int col, int batas) {
if (row <= batas) {
if (col <= row) {
System.out.print("* ");
}
if (col == row) {
System.out.println();
cetakSegitigaSiku(++row, 1, batas);
}
else {
cetakSegitigaSiku(row, ++col, batas);
}
}
}
}

public class JavaApplication {

public static void main(String[] args) {
int hasil = rekursif(5);
System.out.print(hasil);
}
public static Integer rekursif(int n){
if(n == 0 || n == 1){
return 1;
}else{
return n* rekursif(n-1);
}
}
}

public class JavaApplication {

public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
int hasil = fiboRekursif(i);
System.out.print(hasil + " ");
}
}
public static Integer fiboRekursif(int n) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
return fiboRekursif(n - 1) + fiboRekursif(n - 2);
}
}

import java.util.Scanner;
public class palindrome {
static boolean kataPalindrome(String kata) {
int left = 0;
int right = kata.length()-1;
 while (left < right) {
if (kata.charAt(left) != kata.charAt(right)) {
return false;
}
left++;
right--;
}
return true;
}
public static void main (String args []) {
Scanner input = new Scanner(System.in);
System.out.println("PALINDROME CHECKER");
System.out.println("==================");
System.out.print("\ninput kalimat : ");
String kata2 = input.nextLine();
if (kataPalindrome(kata2))
System.out.println(kata2+" adalah Palindrome");
else
System.out.println(kata2+" Bukan Palindrome");
}
}

import java.util.Scanner;
public class Hanoi {
public static void main(String[]args) {
Scanner input = new Scanner(System.in);
System.out.println("jumlah piringan?");
int N=input.nextInt();
System.out.println();
hanoi(N, 'a', 'b', 'c');
}
static void hanoi(int n, char awal, char temp, char akhir) {
if(n==1)
System.out.println("pindahkan "+n+" dari "+awal+" ke "+akhir);
else{
hanoi(n-1, awal,akhir,temp);
System.out.println("pindahkan "+n+" dari "+awal+" ke "+akhir);
hanoi(n-1,temp,awal,akhir);
}
}
}
public class prima {
private static int ambilNilaiRekursif(int number, int index){
if (index == 1) {
return 1;
}
else if (number % index == 0) {
return 1 + ambilNilaiRekursif(number, --index);
} else {
return 0 + ambilNilaiRekursif(number, --index);
}
}
public static boolean cekBilanganPrima(int num){
if (num > 1) {
return (ambilNilaiRekursif(num, num) == 2);
 PRAKTIKUM 6
TUMPUKAN ATAU STACK
Salah satu konsep yang efektif untuk menyimpan dan mengambil data adalah
“terakhir masuk sebagai pertama yang keluar” (Last In First Out/FIFO). Dengan
konsep ini, pengambilan data akan berkebalikan urutannya dengan penyimpanan
data. Stack(tumpukan) adalah sebuah kumpulan data dimana data yang diletakkan di
atas data yang lain. Dengan demikian stack adalah struktur data yang menggunakan
konsep LIFO. Elemen terakhir yang disimpan dalam stack menjadi elemen pertama
yang diambil. Dalam proses komputasi, untuk meletakkan sebuah elemen pada
bagian atas stack disebut dengan push. Dan untuk memindahkan dari tempat teratas
tersebut, kita melakukan pop.

Gambar 1. Ilustrasi Stack

Ada 2 operasi paling dasar dari stack yang dapat dilakukan, yaitu :
1. Operasi push yaitu operasi menambahkan elemen pada urutan terakhir (paling
atas).
2. Operasi pop yaitu operasi mengambil sebuah elemen data pada urutan terakhir
dan menghapus elemen tersebut dari stack.
Operasi pada Stack :
a. Push

void Push (NOD **T, char item)

{
NOD *n;
n=NodBaru (item);
n->next=*T;
*T=n;
}
b. Pop

char Pop (NOD **T)

{
NOD *n; char item;
if (!StackKosong(*T)) {
P=*T;
*T=(*T)->next;
item=P->data;
 free(P);
}
return item;
}

• buat stack (stack) - create

membuat sebuah stack baru yang masih kosong
spesifikasi:
tujuan : mendefinisikan stack yang kosong
input : stack
syarat awal : tidak ada
output stack : - (kosong)
syarat akhir : stack dalam keadaan kosong
• stack kosong (stack) - empty
fungsi untuk menentukan apakah stack dalam keadaan kosong atau tidak
spesifikasi:
tujuan : mengecek apakah stack dalam keadaan kosong
input : stack
syarat awal : tidak ada
output : boolean
syarat akhir : stack kosong bernilai true jika stack dalam keadaan kosong
• stack penuh (stack) - full
fungsi untuk memeriksa apakah stack yang ada sudah penuh
spesifikasi:
tujuan : mengecek apakah stack dalam keadaan penuh
input : stack
syarat awal : tidak ada
output : boolean
syarat akhir : stack penuh bernilai true jika stack dalam keadaan penuh
• push (stack, info baru)
menambahkan sebuah elemen kedalam stack.
spesifikasi:
tujuan : menambahkan elemen, info baru pada stack pada posisi paling atas
input : stack dan Info baru
syarat awal : stack tidak penuh
output : stack
syarat akhir : stack bertambah satu elemen
• pop (stack, info pop)
mengambil elemen teratas dari stack
spesifikasi:
tujuan : mengeluarkan elemen dari stack yang berada pada posisi paling atas
input : stack
syarat awal : stack tidak kosong
output : stack dalam info pop
syarat akhir : stack berkurang satu elemen
Contoh Pemanfaatan Stack
Notasi Postfix dan Infix
Salah satu penggunaan stack adalah mengubah notasi infix menjadi postfix. Berikut
ini adalah algoritma untuk mengubah notasi infix menjadi notasi postfix:
1. Baca ungkapan dalam notasi infix, misalnya S, tentukan panjang ungkapan
tersebut, misalnya N karakter, siapkan sebuah stack kosong dan siapkan derajad
masingmasing operator, misalnya: ^ berderajad 3, * dan / berderajad 2, + dan –
berderajad 1 dan ( berderajad 0.
2. Dimulai dari i = 1 sampai N kerjakan langkah-langkah sebagai berikut:
a. R = S[I]
b. Test nilai R. Jika R adalah:
operand : langsung ditulis
kurung buka : push ke dalam tumpukan
kurung tutup : pop dan tulis semua isi tumpukan sampai ujung tumpukan = ‘(‘. Pop
juga tanda ‘(‘ ini, tetapi tidak usah ditulis
operator : jika tumpukan kosong atau derajad R lebih tinggi dibanding derajad
ujung tumpukan, push operator ke dalam tumpukan. Jika tidak, pop ujung tumpukan
dan tulis; kemudian ulangi pembandingan R dengan ujung tumpukan. Kenudian R di-
push
c. Jika akhir notasi infix telah tercapai, dan tumpukan masih belum kosong, pop
semua isi tumpukan dan tulis hasilnya. Untuk memahami algoritma di atas, kita coba
mengubah ungkapan berikut, yang ditulis menggunakan notasi infix, menjadi notasi
postfix
( A + B ) / (( C – D ) * E ^ F)
Ilustrasi pengubahan notasi infix di atas menjadi notasi postfix secara lengkap. tersaji
dalam tabel sebagai berikut:
Tabel 1. Proses Mengubah Notasi Infix menjadi Postfix

Dari ilustrasi di atas, bisa kita lihat bahwa notasi postfix dari ungkapan:
( A + B ) / (( C – D ) * E ^ F)
adalah
AB+CD–F^*
Tabel 2. Contoh Infix ke Postfix

import java.util.Stack;
public class InfixToPostfix {
String infixExp = "";
String postfixExp = "";
Stack<Character> s = new Stack<Character>();
public void setInfixExp(String infixExp) {
this.infixExp = infixExp;
}
public boolean isOperator(char ch) {
if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '^') {
return true;
}
return false;
}
public int degreeOp(char op) {
if (op == '+' || op == '-') {
 return 1;
} else if (op == '*' || op == '/') {
return 2;
} else if (op == '^') {
return 3;
} else {
return 0;
}
}
public String toPostfix() {
char ch;
 PRAKTIKUM 7
QUEUE / ANTRIAN
A. Tujuan
Mahasiswa mampu :
Memahami struktur data queue
Memahami cara pengoperasian struktur data queue
Mengimplementasikan struktur data queue dengan array dan linked list
B. Dasar Teori
Antrian (queue) adalah sekumpulan elemen, jika ada elemen baru yang
ditambahkan, maka elemen tersebut akan berada di bagian belakang antrian Jika
ada elemen yang harus dihapus atau keluar dari antrian, maka elemen yang keluar
adalah elemen yang berada di sisi depan antrian. Atau konsep ini sering juga
disebut dengan konsep FIFO (First In First Out). Operasi yang terdapat pada queue
adalah:
• Enqueue atau push adalah proses untuk memasukkan elemen artinya menambah
data baru.
• Dequeue atau pop adalah proses untuk mengeluarkan elemen artinya
menghapus data.
• Peek adalah proses untuk mengetahui elemen yang paling depan.
• Front : pointer bantu yang digunakan untuk menunjuk element yang paling
depan.
• Rear : pointer bantu yang digunakan untuk menunjuk element yang paling
belakang.
Array pada Queue
Array pada Queue adalah suatu array yang dibuat seakan-akan merupakan suatu
garis lurus dengan satu pintu masuk dan satu pintu keluar. Pada gambar 1
merupakan implementasi queue menggunakan array. qfront untuk menandai
elemen yang pertama, sedangkan qback untuk menambahkan elemen baru pada
queue.

Circular Bounded Queue

Cara mensimulasikan antrian secara circular dalam array linear menggunakan
arithmetic modular. Arithmetic modular menggunakan ekspresi rumus (X % N)
untuk menjaga besarnya nilai X pada range 0:N-1. Jika indeks telah sampai pada N
dengan penambahan atau pengurangan tersebut, maka indeks akan diset pada
angka 0. Hal yang sama juga dilakukan pada Front jika dilakukan pengambilan
 item dari antrian. Setelah mengambil item dari antrian, kita melakukan increment
terhadap Front untuk penunjukanpada posisi sesudahnya. Apabila indeks telah
berada pada N, maka indeks diset juga pada angka0.

Move qback forward: qback = (qback + 1) % qcapacity;

Move qfront forward: qfront = (qfront + 1) % qcapacity;
Operasi Pada Queue
a) Deklarasi
b) Inisialisasi
c) Cek kosong
d) Cek penuh
e) Penambahan
f) Pengambilan
g) Pengaksesan

import java.util.LinkedList;
import java.util.Queue;
public class QueueAntrian {
public void queueExample() {
Queue queue = new LinkedList();
queue.add("Cau");
queue.add("Apel");
queue.offer("Kadongdong");
queue.offer("Sampeu");
System.out.println("remove: " + queue.remove());
System.out.println("element: " + queue.element());
System.out.println("poll: " + queue.poll());
System.out.println("peek: " + queue.peek());
}
public static void main(String[] args) {
new MainDemo().queueExample();
}
 Karena di File Tidak Ada Praktikum 8 nya, jadi langsung ke Praktikum 9

PRAKTIKUM 9
Sorting & Searching
A. Tujuan
Mahasiswa mampu :
Memahami sorting dan searching
Memahami algoritma Shell Sort, Quick Sort, Binary Search, Linear Search
Mengimplementasikan sorting dan searching
B. Sub Topik
• Shell Sort
• Quick Sort
• Binary Search
• Linear Search
• Implementasi Shell Sort
• Implementasi Quick Sort
• Implementasi Binary Search
• Implementasi Linear Search
C. Dasar Teori
Shell Sort
Metode ini disebut juga dengan metode pertambahan menurun (diminishing
increment). Metode ini dikembangkan oleh Donald L. Shell pada tahun 1959,
sehingga sering disebut dengan Metode Shell Sort. Metode ini mengurutkan
data dengan cara membandingkan suatu data dengan data lain yang memiliki
jarak tertentu, kemudian dilakukan penukaran bila diperlukan Proses
pengurutan dengan metode Shell dapat dijelaskan sebagai berikut :
Pertama-tama adalah menentukan jarak mula-mula dari data yang akan
dibandingkan, yaitu N / 2. Data pertama dibandingkan dengan data dengan
jarak N / 2. Apabila data pertama lebih besar dari data ke N / 2 tersebut maka
kedua data tersebut ditukar. Kemudian data kedua dibandingkan dengan
jarak yang sama yaitu N / 2. Demikian seterusnya sampai seluruh data
dibandingkan sehingga semua data ke-j selalu lebih kecil daripada data ke-(j
+ N / 2).
Pada proses berikutnya, digunakan jarak (N / 2) / 2 atau N / 4. Data
pertama dibandingkan dengan data dengan jarak N / 4. Apabila data
pertama lebih besar dari data ke N / 4 tersebut maka kedua data tersebut
ditukar. Kemudian data kedua dibandingkan dengan jarak yang sama yaitu
N / 4. Demikian seterusnya sampai seluruh data dibandingkan sehingga
 semua data ke-j lebih kecil daripada data ke-(j + N / 4). Pada proses
berikutnya, digunakan jarak (N / 4) / 2 atau N / 8. Demikian seterusnya
sampai jarak yang digunakan adalah 1. Algoritma metode Shell dapat
dituliskan sebagai berikut :
1 Jarak ← N
2 Selama (Jarak > 1) kerjakan baris 3 sampai dengan 9
3 Jarak ← Jarak / 2. Sudah ← false
4 Kerjakan baris 4 sampai dengan 8 selama Sudah = false
5 Sudah ← true
6j←0
7 Selama (j < N – Jarak) kerjakan baris 8 dan 9
8 Jika (Data[j] > Data[j + Jarak] maka tukar Data[j], Data[j
+ Jarak]. Sudah ← true
9j←j+1
Untuk lebih memperjelas langkah-langkah algoritma penyisipan langsung
dapat dilihat pada tabel 1. Proses pengurutan pada tabel 1 dapat dijelaskan
sebagai berikut:
• Pada saat Jarak = 5, j diulang dari 0 sampai dengan 4. Pada pengulangan
pertama, Data[0] dibandingkan dengan Data[5]. Karena 12<17, maka tidak
terjadi penukaran. Kemudian Data[1] dibandingkan dengan Data[6]. Karena
35>23 maka Data[1] ditukar dengan Data[6]. Demikian seterusnya sampai
j=4.
• Pada saat Jarak = 5/2 = 2, j diulang dari 0 sampai dengan 7. Pada
pengulangan pertama, Data[0] dibandingkan dengan Data[2]. Karena 12>9
maka Data[0] ditukar dengan Data[2]. Kemudian Data[1] dibandingkan
dengan Data[3] juga terjadi penukaran karena 23>11. Demikian seterusnya
sampai j=7. Perhatikan untuk Jarak = 2 proses pengulangan harus dilakukan
lagi karena ternyata Data[0] > Data[2]. Proses pengulangan ini berhenti bila
Sudah=true.
• Demikian seterusnya sampai Jarak=1.
Contoh Programnya :

import java.util.*;
public class ShellSort{
public static void sort(int[] array) {
int inner, outer;
int temp;
int h = 1;
while (h <= array.length / 3) {
h = h * 3 + 1;
}
 while (h > 0) {
for (outer = h; outer < array.length; outer++) {
temp = array[outer];
inner = outer;
while (inner > h - 1 && array[inner - h] >= temp) {
array[inner] = array[inner - h];
inner -= h;
}
array[inner] = temp;
}
h = (h - 1) / 3;
}
}
public static void main(String[] args) {
int [] array = {5,3,0,2,4,1,0,5,2,3,1,4};
System.out.println("Before: " + Arrays.toString(array));
sort(array);
System.out.println("After: " + Arrays.toString(array));
}}
Quick Sort
Quick Sort mengurutkan data dengan pendekatan divide-and-conquer, yaitu
membagi masalah semula menjadi beberapa submasalah sejenis yang lebih kecil dan
menyelesaikannya . quick sort melakukan pengurutan dalam putaran secara rekursif
jika data yang di urutkan lebih dari satu buah.
Berikut contoh programnya :

import java.util.*;
public class QuickSort {
public static void swap (int A[], int x, int y) {
int temp = A[x];
A[x] = A[y];
A[y] = temp;
}
public static int partition(int A[], int f, int l) {
int pivot = A[f];
while (f < l) {
while (A[f] < pivot) f++;
while (A[l] > pivot) l--;
swap (A, f, l);
}
return f;
}
public static void Quicksort(int A[], int f, int l) {
if (f >= l) return;
int pivotIndex = partition(A, f, l);
Quicksort(A, f, pivotIndex);
Quicksort(A, pivotIndex+1, l);
}
public static void main(String argv[]) {
int []numbers={55,2,93,1,23,10,66,12,7,54,3};
System.out.println(Arrays.toString(numbers));
Quicksort(numbers, 0, numbers.length-1);
System.out.println(Arrays.toString(numbers));
}
}
Binary Search
Binary search tree adalah salah satu bentuk dari pohon. Di mana masing-masing
pohon tersebut hanya memiliki dua buah upapohon, yakni upapohon kiri dan
upapohon kanan.Ciri khas yang melekat pada binary search tree ini yang bisa juga
dibilang sebagai keunggulan dari binary search tree adalah peletakan isi dari
nodenya yang terurut berdasarkan besarnya dari isinya tersebut. Isinya bisa saja
berupa integer, karakter, atau apapun sesuai dengan spesifikasi binary search tree
yang ada.
Contoh Programnya adalah :

import java.util.Scanner;
class BinarySearch
{
public static void main(String args[])
{
int c, first, last, middle, n, search, array[];
Scanner in = new Scanner(System.in);
System.out.println("Enter number of elements");
n = in.nextInt();
array = new int[n];
System.out.println("Enter " + n + " integers");
for (c = 0; c < n; c++)
array[c] = in.nextInt();

System.out.println("Enter value to find");

search = in.nextInt();

first = 0;
last = n - 1;
middle = (first + last)/2;
while( first <= last )
{
if ( array[middle] < search )
first = middle + 1;
else if ( array[middle] == search )
{
System.out.println(search + " found at location " + (middle + 1) + ".");
break;
}
else
last = middle - 1;
middle = (first + last)/2;
}
if (first > last)
System.out.println(search + " isn't present in the list.\n");
}
}

Linear Search
Algoritma linear search adalah algoritma pencarian yang paling sederhana. Linear
search bekerja dengan membandingkan nilai yang dicari dengan setiap element
pada array (biasanya).
di bawah ini merupakan contoh program linear search dalam bahasa java :

import java.util.Scanner;
class LinearSearch
{
public static void main(String args[])
{
int c, n, search, array[];
Scanner in = new Scanner(System.in);
System.out.println("Enter number of elements");
n = in.nextInt();
array = new int[n];
System.out.println("Enter " + n + " integers");
for (c = 0; c < n; c++)
array[c] = in.nextInt();
System.out.println("Enter value to find");
search = in.nextInt();
for (c = 0; c < n; c++)
{
if (array[c] == search) /* Searching element is present */
{
System.out.println(search + " is present at location " + (c + 1) + ".");
break;
}
}
if (c == n) /* Element to search isn't present */
System.out.println(search + " isn't present in array.");
}
}
 PRAKTIKUM 10
COLLECTION & ARRAY LIST SET
Collection adalah suatu obyek yang bisa digunakan untuk menyimpan sekumpulan
obyek. Obyek yang ada dalam Collection disebut elemen. Collection menyimpan
elemen yang bertipe Object, sehingga berbagai tipe obyek bisa disimpan dalam
Collection. Class-class mengenai Collection tergabung dalam Java Collection
Framework. Collection terbagi menjadi 3 kelompok yaitu Set, List dan Map.
• Set
Set mengikuti model himpunan, dimana obyek/anggota yang tersimpan dalam Set
harus unik. Urutan maupun letak dari anggota tidaklah penting, hanya keberadaan
anggota saja yang penting. Class-class yang mengimplementasikan interface Set
adalah HashSet. Interface SortedSet merupakan subInterface dari interface Set.
Untuk mengurutkan Set, kita dapat menggunakan class yang
mengimplementasikan interface SortedSet yaitu class TreeSet.
• List
List digunakan untuk menyimpan sekumpulan obyek berdasarkan urutan masuk
(ordered) dan menerima duplikat. Terdapat interface Queue yang cara
penyimpanan seperti List, interface ini menyimpan obyek menggunakan metode
FIFO (First In First Out) yaitu obyek yang masuk pertama keluar pertama.
• Map
Perbedaaan mendasar map dengan collection yang lain, untuk menyimpan obyek
pada Map, perlu sepasang obyek, yaitu key yang bersifat unik dan nilai yang
disimpan. Untuk mengakses nilai tersebut maka kita perlu mengetahui key dari
nilai tersebut. Map juga dikenal sebagai dictionary/kamus.
Hirarki dali Collection
Contoh Programnya :

import java.util.HashSet;
public class HashSetExample {
public static void main(String args[]) {
HashSet<String> hset =
new HashSet<String>();
hset.add("Apple");
hset.add("Mango");
hset.add("Grapes");
hset.add("Orange");
hset.add("Fig");
hset.add("Apple");
hset.add("Mango");
hset.add(null);
hset.add(null);
System.out.println(hset);
}
}

import java.util.TreeSet;
public class TreeSetExample {
public static void main(String args[]) {
TreeSet<String> tset = new TreeSet<String>();
// Adding elements to TreeSet<String>
tset.add("ABC");
tset.add("String");
tset.add("Test");
tset.add("Pen");
tset.add("Ink");
tset.add("Jack");
System.out.println(tset);
TreeSet<Integer> tset2 = new TreeSet<Integer>();
tset2.add(88);
tset2.add(7);
tset2.add(101);
tset2.add(0);
tset2.add(3);
tset2.add(222);
System.out.println(tset2);
}
}

import java.util.LinkedHashSet;
public class LinkedHashSetExample {
public static void main(String args[]) {
LinkedHashSet<String> lhset = new LinkedHashSet<String>();
lhset.add("Z");
lhset.add("PQ");
lhset.add("N");
lhset.add("O");
lhset.add("KK");
lhset.add("FGH");
System.out.println(lhset);
 LinkedHashSet<Integer> lhset2 = new LinkedHashSet<Integer>();
lhset2.add(99);
lhset2.add(7);
lhset2.add(0);
lhset2.add(67);
lhset2.add(89);
lhset2.add(66);
System.out.println(lhset2);
}
}

import java.util.*;
class JavaExampleArraylist{
public static void main(String args[]){
ArrayList<String> alist=new ArrayList<String>();
alist.add("Steve");
alist.add("Tim");
alist.add("Lucy");
alist.add("Pat");
alist.add("Angela");
alist.add("Tom");
System.out.println(alist);
alist.add(3, "Steve");
System.out.println(alist);
}
}
import java.util.Scanner;
import java.util.TreeSet;
public class TreesetMhs {
public static void main(String args[]){
Scanner in=new Scanner(System.in);
TreeSet<String> treeSet = new TreeSet<String>();
System.out.print("Masukan Nama Yang Ingin di Masukan\t :");
String mhs = in.nextLine();
treeSet.add(mhs);
System.out.print("Nama Mahasiswa yang di Tambahkan\t: "+treeSet);
}
}

import java.util.*;
class ArraylistMhs{
public static void main(String args[]){
ArrayList<String> alist=new ArrayList<String>();
Scanner in=new Scanner(System.in);
System.out.print("Masukan Nama Yang Ingin di Masukan\t :");
String mhs = in.nextLine();
alist.add(mhs);
System.out.print("Nama Mahasiswa yang di Tambahkan\t: "+alist);
}
}
 PRAKTIKUM 11
SINGLE LINKEDLIST DAN DOUBLE LINKEDLIST
Single Linked list adalah sekumpulan elemen bertipe sama, yang mempunyai
keterurutan tertentu, yang setiap elemennya terdiri dari dua bagian. Struktur berupa
rangkaian elemen saling berkait dimana setiap elemen dihubungkan elemen lain
melalui pointer. Pointer adalah alamat elemen.Penggunaan pointer untuk mengacu
elemen berakibat elemen-elemen bersebelahan secara logik walau tidak
bersebelahan secara fisik di memori.
Double Linked List terdiri dari tiga bagian yaitu untuk menyimpan nilai dan
dua reference yang menunjuk ke node selanjutnya (next node) dan node sebelumnya
(previous node). Untuk bergerak maju dan mundur pada double linked list
menggunakan link next dan prev pada node.
Contoh Programnya :
LINKED LIST
public class Node {
int data;
Node next;
public Node(int data){
this.data = data;
}
public void tampil(){
System.out.print("{"+data+"}");
}
}
public class LinkedList {
Node first ;
public LinkedList(){
first = null;
}
public boolean isEmpty(){
return (first==null);
}
public void addFirst(int data){
Node node = new Node(data);
node.next = first;
first = node;
}
public void addLast(int data){
Node node, help;
node = new Node(data);
node.next = null;
if(isEmpty()){
first = node;
first.next = null;
}else{
help = first;
while(help.next!=null){
help=help.next;
}
help.next=node;
}
}
public Node deleteFirst(){
 if(!isEmpty()){
Node temp = first;
first = first.next;
return temp;
}else{
return null;
}
}
public Node deleteLast(){
if(!isEmpty()){
Node temp, current;
current=first;
while(current.next.next != null){
current=current.next;
}
temp=current.next;
current.next=null;
return temp;
}else{
Node temp = first;
first = null;
return temp;
}
}
public void tampilkan(){
Node current = first;
if(current == null){
System.out.println("Kosong!");
}else{
while(current != null){
current.tampil();
current = current.next;
}
System.out.println();
}
}
}

public class LinkedListApp {

public static void main(String[] args) {
LinkedList link = new LinkedList();
link.addFirst(1);
link.addFirst(2);
link.addLast(3);
link.addLast(4);
link.tampilkan();
link.deleteLast();
link.tampilkan();
}
}

DOUBLE LINKED LIST

public class DNode {
int data;
DNode next;
DNode prev;
 public DNode(int data){
this.data = data;
}
public void tampil(){
System.out.print("{"+data+"}");
}
}
public class DoubleLinkedList {
DNode first;
DNode last;
//kontruktor
//set nilai awal adalah null
public DoubleLinkedList() {
first = null;
last = null;
}
//mengecek apakah linked list kosong atau tidak
public boolean isEmpty(){
return (first==null);
}
//method untuk menginsert data dari pertama
public void insertFirst(int data){
DNode node = new DNode(data);
if(isEmpty()){
last = node;
}else{
first.prev = node;
}
node.next = first;
first = node;
}
//method untuk menginsert data dari terakhir
public void insertLast(int data){
DNode node = new DNode(data);
if( isEmpty() )
first = node;
else{
last.next = node;
node.prev = last;
}
last = node;
}
//method untuk menginsert data pertama
public DNode deleteFirst(){
DNode temp = first;
if(first.next == null)
last = null;
else
first.next.prev = null;
first = first.next;
return temp;
}
//method untuk menghapus data terakhir
public DNode deleteLast(){
DNode temp = last;
if(first.next == null)
 first = null;
else
last.prev.next = null;
last = last.prev;
return temp;
}
//method untuk menginsert data di tengah
public boolean insertAfter(int key, int data){
DNode current = first;
while(current.data != key){
current = current.next;
if(current == null)
return false;
}
DNode node = new DNode(data);
if(current==last){
node.next = null;
last = node;
}else{
node.next = current.next;
current.next.prev = node;
}
node.prev = current;
current.next = node;
return true;
}
//method untuk menghapus data yang dipilih
public DNode deleteKey(int key){
DNode current = first;
while(current.data != key){
current = current.next;
if(current == null)
return null;
}
if(current==first)
first = current.next;
else
current.prev.next = current.next;
if(current==last)
last = current.prev;
else
current.next.prev = current.prev;
return current;
}
//menampilkan data dari pertama - terakhir
public void displayForward(){
System.out.print("List (first-->last): ");
DNode current = first;

while(current != null){
current.tampil();
current = current.next;
}
System.out.println("");
}
//menampilkan data dari terakhir - pertama
 public void displayBackward(){
System.out.print("List (last-->first): ");
DNode current = last;
while(current != null){
current.tampil();
current = current.prev;
}
System.out.println("");
}
}
public class DoubleLinkedListApp {
public static void main(String[] args){
DoubleLinkedList theList = new DoubleLinkedList();
theList.insertFirst(22);
theList.insertFirst(44);
theList.insertFirst(66);
theList.insertLast(11);
theList.insertLast(33);
theList.insertLast(55);
theList.displayForward();
theList.displayBackward();
theList.deleteFirst();
theList.deleteLast();
theList.deleteKey(11);
theList.displayForward();
theList.insertAfter(22, 77);
theList.insertAfter(33, 88);
theList.displayForward();
}
}
 PRAKTIKUM 12
TREE
Struktur pohon (tree) biasanya digunakan untuk menggambarkan hubungan
yang bersifat
hirarkis antara elemen-elemen yang ada. Contoh penggunaan struktur pohon :
• Silsilah keluarga
• Hasil pertandingan yang berbentuk turnamen
• Struktur organisasi dari sebuah perusahaan
Sebuah binary tree adalah sebuah pengorganisasian secara hirarki dari
beberapa buah simpul, dimana masing-masing simpul tidak mempunyai anak lebih
dari 2. Simpul yang berada di bawah sebuah simpul dinamakan anak dari simpul
tersebut.
Simpul yang berada di atas sebuah simpul dinamakan induk dari simpul
tersebut Masing-masing simpul dalam binary tree terdiri dari tiga bagian yaitu
sebuah data dan dua buah pointer yang dinamakan pointer kiri dan kanan. Simpul
juga mempunyai sibling, descendants, dan ancestors. Sibling dari sebuah simpul
adalah anak lain dari induk simpul tersebut. Descendants dari sebuah simpul adalah
semua simpul-simpul merupakan cabang (berada di bawah) simpul tersebut.
Anchestors dari sebuah simpul adalah semua simpul yang berada di atas antara
simpul tersebut dengan root.
Binary Tree Pree Order

In Order Post Order

Contoh Pengaplikasian dalam Programnya :

class BT
{
private BTNode root;
public BT()
{
root = null;
}
public boolean isEmpty()
{
return root == null;
}
public void insert(int data)
{
root = insert(root, data);
}
private BTNode insert(BTNode node, int data)
{
if (node == null)
node = new BTNode(data);
else
{
if (node.getRight() == null)
node.right = insert(node.right, data);
else
node.left = insert(node.left, data);
}
return node;
}
public int countNodes()
{
return countNodes(root);
}
private int countNodes(BTNode r)
{
if (r == null)
return 0;
else
{
int l = 1;
l += countNodes(r.getLeft());
l += countNodes(r.getRight());
return l;
}
}
public void inorder()
{
inorder(root);
}
private void inorder(BTNode r)
{
if (r != null)
{
inorder(r.getLeft());
System.out.print(r.getData() +" ");
inorder(r.getRight());
}
}
public void preorder()
{
preorder(root);
}
private void preorder(BTNode r)
{
if (r != null)
{
System.out.print(r.getData() +" ");
preorder(r.getLeft());
preorder(r.getRight());
}
 }
public void postorder()
{
postorder(root);
}
private void postorder(BTNode r)
{
if (r != null)
{
postorder(r.getLeft());
postorder(r.getRight());
System.out.print(r.getData() +" ");
}
}
}
 PRAKTIKUM 13
HASH
Hash merupakan salahsatu fasilitas yang telah di sediakan oleh java untuk
memudahkan pelabelan suatu array. Kalau di analogi kan hash seperti kamus, ketika
memanggil kata tertentu, nanti akan keluar hasil balik dari kata kunci tersebut.

Contoh Program Hash

import java.util.Collection;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Set;
public class HashtableDemo {
public static void main(String args[]) {
Hashtable companies = new Hashtable();
companies.put("Google", "United States");
companies.put("Nokia", "Finland");
companies.put("Sony", "Japan");
companies.get("Google");
System.out.println("Does hashtable contains Google as key: " +
companies.containsKey("Google"));
System.out.println("Does hashtable contains Japan as value: "+
companies.containsValue("Japan"));
Enumeration enumeration = companies.elements();
while (enumeration.hasMoreElements()) {
System.out.println("hashtable values: " + enumeration.nextElement());}
System.out.println("Is companies hashtable empty: "+ companies.isEmpty());
System.out.println("Size of hashtable in Java: " + companies.size());
Set hashtableKeys = companies.keySet();
Enumeration hashtableKeysEnum = companies.keys();
Enumeration hashtableValuesEnum = companies.elements();
Collection hashtableValues = companies.values();
companies.clear();
}
}
Contoh 2

import java.util.Hashtable;
import java.util.Enumeration;
public class HashtableExample {
public static void main(String[] args) {
Enumeration names;
String key;
Hashtable<String, String> hashtable = new Hashtable<String, String>();
hashtable.put("Key1","Chaitanya");
hashtable.put("Key2","Ajeet");
hashtable.put("Key3","Peter");
hashtable.put("Key4","Ricky");
hashtable.put("Key5","Mona");
names = hashtable.keys();
while(names.hasMoreElements()) {
key = (String) names.nextElement();
System.out.println("Key: " +key+ " & Value: " +
hashtable.get(key));
}
}
}
 PRAKTIKUM 14
GRAPH
Sebuah graph G=<V,E> terdiri dari sekumpulan titik (vertices) V dan sekumpulan
garis (edges) E. Sebuah garis e = (u,v) menghubungkan dua titik u dan v. Self – loop
adalah garis yang menghubungkan ke titik itu sendiri.

Vertices = {v1, v2, v3, …, vm}

Edges = {e1, e2, e3, …, en}

Dua titik u, v dikatakan adjacent to u, jika u dan v dihubungkan dengan garis. Path
antara dua titik v dan w adalah sekumpulan garis yang menghubungkan titik v ke titik
w. Panjang path adalah jumlah garis dalam path.

DFS dan BFS

Contoh Program DFS :

import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.Stack;
public class DFS {
private Stack<Integer> stack;
public DFS() {
stack = new Stack<Integer>();
}
public void dfs(int adjacency_matrix[][], int source){
int number_of_nodes = adjacency_matrix[source].length - 1;
int visited[] = new int[number_of_nodes + 1];
int element = source;
int i = source;
System.out.print(element + "\t");
visited[source] = 1;
stack.push(source);
while (!stack.isEmpty()){
element = stack.peek();
i = element;
while (i <= number_of_nodes){
if (adjacency_matrix[element][i] == 1 && visited[i] == 0){
stack.push(i);
visited[i] = 1;
element = i;
 i = 1;
System.out.print(element + "\t");
continue;
}
i++;
}
stack.pop();
}
}
public static void main(String...arg){
int number_of_nodes, source;
Scanner scanner = null;
try{
System.out.println("Enter the number of nodes in the graph");
scanner = new Scanner(System.in);
number_of_nodes = scanner.nextInt();
int adjacency_matrix[][] = new int[number_of_nodes + 1][number_of_nodes +
1];
System.out.println("Enter the adjacency matrix");
for (int i = 1; i <= number_of_nodes; i++)
for (int j = 1; j <= number_of_nodes; j++)
adjacency_matrix[i][j] = scanner.nextInt();
System.out.println("Enter the source for the graph");
source = scanner.nextInt();
System.out.println("The DFS Traversal for the graph is given by ");
DFS dfs = new DFS();
dfs.dfs(adjacency_matrix, source);
}catch(InputMismatchException inputMismatch){
System.out.println("Wrong Input format");
}
scanner.close();
}
}

Contoh Program BFS

import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class BFS
{
private Queue<Integer> queue;
public BFS()
{
queue = new LinkedList<Integer>();
}
public void bfs(int adjacency_matrix[][], int source)
{
int number_of_nodes = adjacency_matrix[source].length - 1;
int[] visited = new int[number_of_nodes + 1];
int i, element;
visited[source] = 1;
queue.add(source);
while (!queue.isEmpty())
{
 element = queue.remove();
i = element;
System.out.print(i + "\t");
while (i <= number_of_nodes)
{
if (adjacency_matrix[element][i] == 1 && visited[i] == 0)
{
queue.add(i);
visited[i] = 1;
}
i++;
}
}
}
public static void main(String... arg)
{
int number_no_nodes, source;
Scanner scanner = null;
try
{
System.out.println("Enter the number of nodes in the graph");
scanner = new Scanner(System.in);
number_no_nodes = scanner.nextInt();
int adjacency_matrix[][] = new int[number_no_nodes +
1][number_no_nodes + 1];
System.out.println("Enter the adjacency matrix");
for (int i = 1; i <= number_no_nodes; i++)
for (int j = 1; j <= number_no_nodes; j++)
adjacency_matrix[i][j] = scanner.nextInt();
System.out.println("Enter the source for the graph");
source = scanner.nextInt();
System.out.println("The BFS traversal of the graph is ");
BFS bfs = new BFS();
bfs.bfs(adjacency_matrix, source);
} catch (InputMismatchException inputMismatch)
{
System.out.println("Wrong Input Format");
}
scanner.close();
}
}

Prim vs Kruskal (MST)