Anda di halaman 1dari 0

1

KATA PENGANTAR

Puji Syukur kehadirat Allah SWT, atas rahmat, taufiq dan hidayah-Nya
penyusunan modul struktur data ini dapat terselesaikan.
Modul Struktur data ini disusun menyesuaikan dengan SAP (Satuan
Acara Perkuliahan) dan GBPP (Garis Besar Program dan Pengajaran) program
studi D3 Manajemen Informatika Universitas Trunojoyo. Pembahasan Modul ini
meliputi : Memulai pemrograman java , Dasar pemrograman Java , Seleksi,
Perulangan dan Program Rekursif, Akses terhadap kelas dan unsur pewarisan ,
Array,vector & Matrix , Sorting & Searching, Stack, Queue, Collections,Arraylist,
Set, Singly Linked List & Doubly Linked List, Tree, Hash Table , Graph
Semoga dengan tersusunnya modul praktikum struktur data ini,
mahasiswa dapat lebih memahami dan mampu membuat program JAVA dengan
struktur data yang lebih baik

Bangkalan, 12 Mei 2010


Penyusun






















2

DAFTAR ISI

Kata Pengantar ......................................................................................................... 1
Daftar Isi .................................................................................................................. 2
Memulai Pemrograman Java .................................................................................... 3
Dasar-Dasar Pemrograman Java .............................................................................. 4
Seleksi .................................................................................................................... 11
Perulangan Dan Program Rekursif ........................................................................ 17
Akses Terhadap Kelas Dan Unsur Pewarisan ........................................................ 25
Array, Vector Dan Matrix ...................................................................................... 36
Sorting Dan Searching ........................................................................................... 42
Stack, Queue, Collections,Arraylist, Set ................................................................ 53
Singly Linked List & Doubly Linked List ............................................................. 67
Tree ........................................................................................................................ 82
Hash Table ............................................................................................................. 89
Graph ................................................................................................................... 101

















3
MODUL 1
MEMULAI PEMROGRAMAN JAVA

1. Tujuan

Membuat program java menggunakan text editor dan console

2. Dasar Teori

Console merupakan Tempat untuk menulis perintah(command), Contoh :
Terminal (Linux) , MSDOS Command Prompt (Windows)
Text Editor , Contoh : Notepad, Wordpad, Vi
Integrated Development Environment (IDE) merupakan environment
pemrograman yang terintegrasi pada aplikasi. IDE menyediakan
developer GUI, text atau code editor, compiler/interpreter dan debugger.


3. Tugas Pendahuluan

1. Jelaskan fitur-fitur teknologi Java seperti, Java Virtual Machine(JVM),
garbage collection, dan code security.
2. Jelaskan perbedaan fase-fase pada program Java.

4. Praktikum

Percobaan 1. Program Java pertama

package Hello;

public class Hello {
public static void main(String[ ] args) {
// TODO Auto-generated method stub
System.out.print("Saya mau belajar pemrograman Java");
}
}


5. Tugas Praktikum

1. Berikan penjelasan setiap baris program dari percobaan 1 diatas

4
MODUL 2
DASAR-DASAR PEMROGRAMAN JAVA


1. Tujuan

a. Memahami konsep ADT (Abstract Data Type)
b. Memahami Class dan Object
c. Memahami Kata-kata kunci (keyword) dan operator-operator pada Java


2. Dasar Teori

ADT merupakan kumpulan dari elemen-elemen data yang disajikan
dengan satu set operasi yang digambarkan pada elemen-elemen data
tersebut
Keyword merupakan identifier khusus yang sudah disediakan oleh Java
untuk tujuan tertentu.



3. Tugas Pendahuluan

1. Apa yang dimaksud dengan kelas dan object. Berikan contoh
2. Apa yang dimaksud dengan Java literal, tipe data primitif, tipe variabel,
identifier dan operator. Berikan contoh


4. Praktikum

Percobaan 1a. Program class Mobil ; Package Mobil_1

package Mobil_1;
public class Mobil {

private String Warna;
private int Jumlah_Pintu;
private double Isi_Tangki;



5
public Mobil() {
super();
}

public Mobil(String warna, int jumlah_Pintu, double isi_Tangki) {
super();
Warna = warna;
Jumlah_Pintu = jumlah_Pintu;
Isi_Tangki = isi_Tangki;
}

public String getWarna() {
return Warna;
}

public void setWarna(String warna) {
Warna = warna;
}

public static int Maju(int maju) {
int majukedepan = 0;
majukedepan = majukedepan + maju;
return (majukedepan);
}

public int Mundur(int mundur) {
int mundurbelakang = 0;
mundurbelakang = mundurbelakang + mundur;
return (mundurbelakang);
}

public int getJumlah_Pintu() {
return Jumlah_Pintu;
}

public void setJumlah_Pintu(int jumlah_Pintu) {
Jumlah_Pintu = jumlah_Pintu;
}

public double getIsi_Tangki() {
return Isi_Tangki;
}

6

public void setIsi_Tangki(float isi_Tangki) {
Isi_Tangki = isi_Tangki;
}
}


Percobaan 1b. Program class TestDrive1; package Mobil_1

package Mobil_1;

public class TestDrive1 {
public static void main(String[] args) {
System.out.println("Mobil maju sejauh " + Mobil.Maju(25) + "
meter");
}
}


Percobaan 2a. Program class Mobil, package Mobil_2

package Mobil_2;
public class Mobil {

public String Warna;
private int Jumlah_Pintu;
private double Isi_Tangki;


public Mobil() {
super();
}

public Mobil(String warna, int jumlah_Pintu, double isi_Tangki) {
super();
Warna = warna;
Jumlah_Pintu = jumlah_Pintu;
Isi_Tangki = isi_Tangki;
}

public String getWarna() {
return Warna;

7
}

public void setWarna(String warna) {
Warna = warna;
}

public int Maju(int maju) {
int majukedepan = 0;
majukedepan = majukedepan + maju;
return (majukedepan);
}

public int Mundur(int mundur) {
int mundurbelakang = 0;
mundurbelakang = mundurbelakang + mundur;
return (mundurbelakang);
}

public int getJumlah_Pintu() {
return Jumlah_Pintu;
}

public void setJumlah_Pintu(int jumlah_Pintu) {
Jumlah_Pintu = jumlah_Pintu;
}

public double getIsi_Tangki() {
return Isi_Tangki;
}

public void setIsi_Tangki(float isi_Tangki) {
Isi_Tangki = isi_Tangki;
}
}


Percobaan 2b. Program class TestDrive2, package Mobil_2


package Mobil_2;

public class TestDrive2 {

8
public static void main(String[] args) {
Mobil mobilku = new Mobil();
mobilku.Warna = "merah";
System.out.println
("Mobilku yang berwarna " + mobilku.Warna + " mundur
sebanyak " + mobilku.Mundur(15) + " meter");
}
}


Percobaan 3a. Program class Mobil, package Mobil_3

package Mobil_3;
public class Mobil {

private String Warna;
private int Jumlah_Pintu;
private double Isi_Tangki;


public Mobil() {
super();
}

public Mobil(String warna, int jumlah_Pintu, double isi_Tangki) {
super();
Warna = warna;
Jumlah_Pintu = jumlah_Pintu;
Isi_Tangki = isi_Tangki;
}

public String getWarna() {
return Warna;
}

public void setWarna(String warna) {
Warna = warna;
}

public int Maju(int maju) {
int majukedepan = 0;
majukedepan = majukedepan + maju;

9
return (majukedepan);
}

public int Mundur(int mundur) {
int mundurbelakang = 0;
mundurbelakang = mundurbelakang + mundur;
return (mundurbelakang);
}

public int getJumlah_Pintu() {
return Jumlah_Pintu;
}

public void setJumlah_Pintu(int jumlah_Pintu) {
Jumlah_Pintu = jumlah_Pintu;
}

public double getIsi_Tangki() {
return Isi_Tangki;
}

public void setIsi_Tangki(float isi_Tangki) {
Isi_Tangki = isi_Tangki;
}
}

Percobaan 3b. Program class TestDrive3, package Mobil_3


package Mobil_3;
import Mobil_3.Mobil;


public class TestDrive3 {
public static void main(String[] args) {
Mobil mobil_Adi = new Mobil("Merah", 4, 7.5);
System.out.println
("Mobilku yang berwarna " + mobil_Adi.getWarna() +
" maju sebanyak " + mobil_Adi.Maju(125) + " meter" + " dan
menghabiskan bensin " + mobil_Adi.getIsi_Tangki() + " liter bok!");
}
}

10

5. Tugas Praktikum

1. Diberikan table dibawah ini, deklarasikan variable yang terdapat didalamnya
dengan tipe data yang sesuai dan berikan inisialisasi. Tampilkan hasil
outputnya yaitu nama variable dan nilainya

Variable name Data tipe Initial value
Number integer 10
Letter character a
Result boolean true
Str String hello

Berikut ini merupakan tampilan yang diharapkan sebagai hasil eksekusi
program :
number = 10
letter = a
result = true
str = hello
2. Buatlah program yang menghasilkan output nilai rata-rata dari tiga angka.
Nilai dari masing-masing tiga angka tersebut adalah 10, 20 dan 45. Tampilan
output yang diharapkan adalah :
number 1 = 10
number 2 = 20
number 3 = 45
Average is = 25

3. Diberikan tiga angka, tuliskan program yang menghasilkan output angka
dengan nilai terbesar dari tiga angka tersebut. Gunakan operator kondisi ?:
(Anda akan memerlukan dua operator ?: ) . Sebagai contoh , diberikan angka
10, 23 dan 5. Program Anda akan menghasilkan output :
number 1 = 10
number 2 = 23
number 3 = 5
Nilai tertingginya adalah angka = 23

4. Diberikan pernyataan berikut, tulis kembali soal tersebut dengan
menambahkan tanda kurung pada urutan sesuai dengan bagaimana pernyataan
tersebut akan dievaluasi.
a / b ^ c ^ d e + f g * h + i
3 * 10 * 2 /15 2 + 4 ^ 2 ^ 2
r ^ s * t / u v + w ^ x y++

11
MODUL 3
SELEKSI

1. Tujuan
Mampu membuat program menerima input dari keyboard
Memahami pernyataan IF
Memahami pernyataan Nested IF (IF bersarang)
Memahami switch...case

2. Dasar Teori
Terdapat dua cara untuk mendapatkan input:
menggunakan class BufferedReader, lewat console
menggunakan class JOptionPane , GUI(graphical user interface)
IF, Nested IF dan switch case merupakan bagian dari Struktur kontrol
keputusan, yang digunakan untuk memilih bagian dari code yang akan
dieksekusi.

3. Tugas Pendahuluan

1. Jelaskan penggunaan class BufferedReader dan class JOptionPane untuk
mendapatkan input dari keyboard. Berikan masing-masing contoh
program sederhana yang menggunakan class-class tersebut

4. Praktikum

Percobaan 1. Input dari keyboard


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

public class IF {
public static void main (String[] args) {
System.out.println("Masukkan bilangan Anda : ");
BufferedReader bfr = new BufferedReader
(new InputStreamReader(System.in));
String angkaInput = null;
try {
angkaInput = bfr.readLine();

12
} catch (IOException e) {
e.printStackTrace();
}
int Data = Integer.valueOf(angkaInput).intValue();
if (Data > 5) System.out.print
("Angka yang anda masukkan lebih besar dari 5");
}
}
Percobaan 2. Pernyataan IF

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

public class IF_ELSE {
public static void main (String[] args){
System.out.println("Masukkan angka Anda : ");
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();
if (Data > 5) System.out.print
("Angka yang anda masukkan lebih besar dari 5");
else System.out.print
("Angka yang anda masukkan lebih kecil dari 5");
}
}

Program 3. Pernyataan Nested IF

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


public class Nested_IF {
public static void main(String[] args) {

13
System.out.println("Masukkan angka Anda : ");
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();
if (Data > 5)
if (Data%2==0)System.out.println("Angka yang anda masukkan
lebih besar dari 5 dan genap.");
else System.out.println("Angka yang anda masukkan lebih besar
dari 5 dan ganjil.");
else
if (Data%2==0)System.out.println("Angka yang anda
masukkan lebih kecil dari 5 dan genap.");
else System.out.println("Angka yang anda masukkan lebih kecil
dari 5 dan ganjil.");
}
}

Percobaan 4. Program AND

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


public class ProgramAND {
public static void main(String[] args) {
System.out.println("Masukkan angka Anda : ");
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();

14
if ((Data%2==0) && (Data%3==0))
System.out.println("Bilangan yang anda masukkan adalah kelipatan 2
dan kelipatan 3.");
else
System.out.println("Bilangan yang anda masukkan bukan kelipatan 2
dan kelipatan 3.");
}

}

Percobaan 5. Program OR

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


public class ProgramOR {
public static void main(String[] args) {
System.out.println("Masukkan angka Anda : ");
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();
if ((Data%2==0) || (Data%3==0))
System.out.println("Bilangan yang anda masukkan adalah kelipatan 2
atau kelipatan 3.");
else
System.out.println("Bilangan yang anda masukkan bukan kelipatan 2
atau kelipatan 3.");
}
}


Percobaan 6. Multiple Action

import java.io.BufferedReader;

15
import java.io.IOException;
import java.io.InputStreamReader;


public class MultipleAction {
public static void main(String[] args) {
System.out.println("Masukkan angka Anda : ");
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();
if (Data > 10) {
double Dataku = Data / 5.0;
System.out.println
("Data yang Anda masukkan " + Data +
" dan hasil baginya dengan 5 adalah " + Dataku);
}
}

}


Percobaan 7. Switch Case

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


public class switch_case {
public static void main(String[] args) {
System.out.println("Masukkan angka Anda : ");
BufferedReader bfr = new BufferedReader
(new InputStreamReader(System.in));
String hurufInput = null;
try {
hurufInput = bfr.readLine();

16
} catch (IOException e) {
e.printStackTrace();
}
int Data = Integer.valueOf(hurufInput).intValue();
switch (Data)
{
case 4 :
System.out.println("Kiri");
break;
case 6 :
System.out.println("Kanan");
break;
case 8 :
System.out.println("Atas");
break;
case 2 :
System.out.println("Bawah");
break;
default :
System.out.println("Masukkan nilai yang
sah.");
System.out.println("4, 6, 8, atau 2");
break;
} }}

5. Tugas Praktikum

1. Ambil tiga nilai ujian dari user dan hitung nilai rata-rata dari nilai
tersebut. Berikan output rata-rata dari tiga nilai ujian. Berikan juga smiley
face pada output jika nilai rata-rata lebih besar atau sama dengan 60,
selain itu beri output :-(
a. Gunakan BufferedReader untuk mendapatkan input dari user,
dan System.out untuk output hasilnya.
b. Gunakan JOptionPane untuk mendapatkan input dari user dan
output hasilnya

2. Ambil sebuah angka sebagai input dari user, dan outputnya berupa kata
yang sesuai dengan angka. Angka yang dimasukkan antara 1-10. Jika user
memasukkan nilai yang tidak sesuai berikan output Invalid number.
a. Gunakan statement if-else untuk menyelesaikan
b. Gunakan statement switch untuk menyelesaikan

17
MODUL 4
PERULANGAN DAN PROGRAM REKURSIF


1. Tujuan

Memahami perulangan (loop) dengan Java
Memahami fungsi Rekursif


2. Dasar Teori

Struktur kontrol perulangan digunanakan untuk mengeksekusi bagian
tertentu sesuai dengan jumlah angka pengulangannya.
Sifat- sifat Rekursif
Dapat digunakan ketika inti dari masalah terjadi berulang kali
Sedikit lebih efisien dari iterasi tapi lebih elegan
Method-methodnya dimungkinkan untuk memanggil dirinya
sendiri
Data yang berada dalam method tersebut seperti argument
disimpan sementara kedalam stack sampai method pemanggilnya
diselesaikan

3. Tugas Pendahuluan

1. Jelaskan beberapa struktur kontrol perulangan yang ada
2. Jelaskan perbedaan Rekursif dan Iterasi

4. Praktikum

Percobaan 1. Program loop_while

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


public class loop_while {
public static void main(String[] args) {
System.out.println("Masukkan angka Anda : ");

18
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();
int i=1;
while (i <= Data) {
System.out.println("Bilangan " + i);
i++;
}
}
}



Percobaan 2. Program loop_do_while

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


public class loop_do_while {
public static void main(String[] args) {
int Data;
do {
System.out.print("Masukkan angka Anda : ");
BufferedReader bfr = new BufferedReader
(new InputStreamReader(System.in));
String angkaInput = null;
try {
angkaInput = bfr.readLine();
} catch (IOException e) {
e.printStackTrace();
}
Data = Integer.valueOf(angkaInput).intValue();
} while (Data != 99);
System.out.println("Anda keluar dari LOOP");

19
}
}


Percobaan 3. Program loop_for

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

public class loop_FOR {
public static void main(String[ ] args) {
System.out.println("Masukkan angka Anda : ");
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();
for(int ulang = 1; ulang<=Data; ulang++) {
System.out.println("Bilangan : " + ulang);
}
}
}


Percobaan 4. program nestedloop

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

public class nestedLOOP {
public static void main(String[] args) {
int ulang = inputData();
buatSegitiga(ulang);
}

private static int inputData() {

20
System.out.print("Masukkan jumlah segitiga yang Anda mau :
");
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;
}

private static void buatSegitiga(int ulang) {
for (int i=1; i<=ulang; i++) {
for (int j=1; j<=(ulang-i); j++) {
System.out.print(" ");
}
for(int k=1; k<=i; k++){
System.out.print("#");
}
System.out.println("");
}
}
}


Percobaan 5. Program TryCatch

public class ProgramDenganTryCatch {
public static void main(String args[]) {
int[] myArray = new int[10];
try {
System.out.println("Sebelum pemberian nilai yang
sah");
myArray[0] = 1;
System.out.println("Sebelum pemberian yang tidak
sah");
// Kode penyeModul kesalahan (exception).
myArray[100] = 1;
System.out.println("Setelah exception array");

21
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Kesalahan dalam indeks array");
}
}
}


Percobaan 6. Program BagidenganNol

public class BagiDenganNol {
public static void main(String[ ] args) {
int bilangan = 100;
System.out.println("Sebelum pembagian");
for(int i=5; i>=0; i--) {
try {
System.out.print
(bilangan + " / " + i + " = ");
System.out.println(bilangan/i);
}
catch(RuntimeException r){
System.out.println(
"Error karena pembagian nol!");
}
finally
{
System.out.println
("Bagian finally dijalankan");
}
}
System.out.println("Selesai");
}
}


Percobaan 7 Program Rekursif Segitiga Phytagoras

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

public class RekursifSegitigaPhytagoras {
public static void main(String[] args) {

22
System.out.print("Masukkan tinggi segitiga Phytagoras : ");
final int tinggi = inputData();
triangle(tinggi);
}

private static int triangle(int n) {
int bilangan = 0;
if (n == 1) {
bilangan = 1;
System.out.println("Bilangan ke-" + n + " adalah " +
bilangan);
return bilangan;
} else {
bilangan = n + triangle(n - 1);
System.out.println("Bilangan ke-" + n + " adalah " +
bilangan);
}
return (bilangan);
}

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;
}
}


Percobaan 8. Program RekursifFaktorial

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

public class RekursifFaktorial {

23

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;
}

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;
}
}



Percobaan 9. Hanoi Rekursif

class HanoiRekursif
{
static int nDisks = 4;
public static void main(String[] args)
{
doTowers(nDisks, 'A', 'B', 'C');
}

24

public static void doTowers(int topN,
char from, char inter, char to)

{
if(topN==1)
System.out.println("Disk 1 dari " + from + " ke "+ to);
else
{
doTowers(topN-1, from, to, inter); // dari --> media tengah.
System.out.println("Disk " + topN +
" dari " + from + " ke "+ to);
doTowers(topN-1, inter, from, to); // media tengah --> ke
}
}
} // Akhir kelas HanoiRekursif


5. Tugas Praktikum

1. Buat sebuah program yang mencetak nama Anda selama seratus kali. Buat
tiga versi program ini menggunakan while loop, do while dan for loop
2. Hitung pangkat sebuah nilai berdasarkan angka dan nilai pangkatnya.
Buat tiga versi dari program ini menggunakan while loop, do while dan
for loop
3. Buat program AnagramRekursif , output diharapkan sebagai berikut :












25
MODUL 5
AKSES TERHADAP KELAS DAN UNSUR PEWARISAN


1. Tujuan

Memahami visibility
Memahami Pewarisan (Inheritance)
Memahami Antarmuka (interface)


2. Dasar Teori

Visibility adalah cara bagaimana suatu data/atribut serta fungsi/metoda
yang dimiliki suatu kelas/objek dapat diakses dari kelas-kelas/bjek-objek
lain. Contoh : public, private, protected, default

3. Tugas Pendahuluan

1. Sebutkan perbedaan public, private, protected dan default
2. Apa yang dimaksud dengan pewarisan (inheritance) ? Berikan contoh


4. Praktikum

Percobaan 1a. package Big_Cat; class Big_Cat

package bigCat;
// Kelas abstrak
public abstract class Big_Cat {
protected static String name;
protected abstract void eat();
}

// Kelas turunan
class Lion extends Big_Cat {
// Kostruktor untuk kelas Lion
public Lion (String nameLion) {
// Mengisi peubah yang diwarisi dari kelas abstrak
Lion.name = nameLion;

26
}
// Implementasi metoda yang diwarisi dari kelas abstrak
public void eat() {
System.out.println("Lion can eat meat.");

}
}

//Kelas turunan
class Tiger extends Big_Cat {
// Kostruktor untuk kelas Lion
public Tiger (String nameTiger) {
// Mengisi peubah yang diwarisi dari kelas abstrak
Tiger.name = nameTiger;
}
// Implementasi metoda yang diwarisi dari kelas abstrak
public void eat() {
System.out.println("Tiger can eat meat and drink milk.");

}
}

//Kelas turunan
class Cat extends Big_Cat {
// Kostruktor untuk kelas Lion
public Cat (String nameCat) {
// Mengisi peubah yang diwarisi dari kelas abstrak
Cat.name = nameCat;
}
// Implementasi metoda yang diwarisi dari kelas abstrak
public void eat() {
System.out.println("Cat can eat meat, drink milk, and sometimes
rice.");
}
}



Percobaan 1b. package bigCat class TestBigCat

package bigCat;


27
public class TestBigCat {
public static void main(String[] args) {

// Memanfaatkan kelas Lion
Lion myLion = new Lion("Simba");
System.out.println("My lion is " + Lion.name);
myLion.eat();

// Memanfaatkan kelas Tiger
Tiger myTiger = new Tiger("Harimau");
System.out.println("My tiger is " + Tiger.name);
myTiger.eat();

// Memanfaatkan kelas Cat
Cat myCat = new Cat("Kucingku manis");
System.out.println("My cat is " + Cat.name);
myCat.eat();
}
}
Percobaan 2a. package bigCatNoOverload class BigCatNoOverload

package bigCatNoOverload;

public class Big_Cat_NoOverload {
protected static String name;
protected void eat() {
System.out.println("Semua kucing besar makan daging!");
}
}
//Kelas turunan
class WildLion extends Big_Cat_NoOverload {
// Kostruktor untuk kelas Lion
public WildLion (String nameLion) {
// Mengisi peubah yang diwarisi dari kelas abstrak
WildLion.name = nameLion;
}
}

//Kelas turunan
class WildTiger extends Big_Cat_NoOverload {
// Kostruktor untuk kelas Lion
public WildTiger (String nameTiger) {

28
// Mengisi peubah yang diwarisi dari kelas abstrak
WildTiger.name = nameTiger;
}
}

//Kelas turunan
class WildCat extends Big_Cat_NoOverload {
// Kostruktor untuk kelas Lion
public WildCat (String nameCat) {
// Mengisi peubah yang diwarisi dari kelas abstrak
WildCat.name = nameCat;
}
}



Percobaan 2b. package bigCatNoOverload class TestNoOverload

package bigCatNoOverload;


public class Test_NoOverload {
public static void main(String[] args) {
// Memanfaatkan kelas Lion
WildLion myLion = new WildLion("Simba");
System.out.println("My lion is " + WildLion.name);
myLion.eat();

// Memanfaatkan kelas Tiger
WildTiger myTiger = new WildTiger("Harimau");
System.out.println("My tiger is " + WildTiger.name);
myTiger.eat();

// Memanfaatkan kelas Cat
WildCat myCat = new WildCat("Kucingku manis");
System.out.println("My cat is " + WildCat.name);
myCat.eat();
}
}


Percobaan 3a. package KucingGarong class Coba_Akses1

29

package KucingGarong;

class Coba_Akses1 {
public static void main (String[] args) {
Kucing kucingku = new Kucing();

// Mengisi peubah instan.
kucingku.Isi_Identitas("Pussy", "Belang", 10);

// Menampilkan nama kucing melalui metoda.
System.out.println("Nama : " + kucingku.ambilNama());

// Menampilkan nama kucing lewat peubah.
System.out.println("Nama : " + kucingku.Nama);
}
}


Percobaan 3b. package KucingGarong class Kucing


package KucingGarong;

class Kucing {
String Nama;
String Warna;
int Berat;

// Metoda
void Isi_Identitas
(String namaKucing, String warnaKucing, int beratKucing) {
Nama = namaKucing;
Warna = warnaKucing;
Berat = beratKucing;
}

String ambilNama() {
return Nama;
}

String ambilWarna() {

30
return Warna;
}

int ambilBerat() {
return Berat;
}
}

Percobaan 4a. package MySweetyCat class Coba_Akses2

package MySweetyCat;

class Coba_Akses2 {
public static void main (String[] args) {
Kucingku_Manis kucingku = new Kucingku_Manis();

// Mengisi peubah instan.
kucingku.Isi_Identitas("Pussy", "Belang", 10);

// Menampilkan nama kucing melalui metoda.
System.out.println("Nama : " + kucingku.ambilNama());

// Menampilkan nama kucing lewat peubah.
System.out.println("Nama : " + kucingku.Nama);
}
}

Percobaan 4b. Package MySweetyCat class Kucingku_Manis

package MySweetyCat;
class Kucingku_Manis {
String Nama;
private String Warna;
private int Berat;

// Metoda
void Isi_Identitas
(String namaKucing, String warnaKucing, int beratKucing) {
Nama = namaKucing;
Warna = warnaKucing;
Berat = beratKucing;
}

31

String ambilNama() {
return Nama;
}

String ambilWarna() {
return Warna;
}

int ambilBerat() {
return Berat;
}
}

Percobaan 5a. package OrangIndonesia class OrangIndonesia

package OrangIndonesia;

public class OrangIndonesia {
protected String Nama;
protected String Alamat;
protected String Pekerjaan;
public OrangIndonesia
(String nama, String alamat, String pekerjaan) {
super();
Nama = nama;
Alamat = alamat;
Pekerjaan = pekerjaan;
}
public String getNama() {
return Nama;
}
public String getAlamat() {
return Alamat;
}
public String getPekerjaan() {
return Pekerjaan;
}
}

class OrangBatak extends OrangIndonesia {
private double Gaji;

32
public OrangBatak
(String nama, String alamat, String pekerjaan) {
super(nama, alamat, pekerjaan);
}
public double getGaji() {
return Gaji;
}
public void setGaji(double gaji) {
Gaji = gaji;
}
}

class OrangJawa extends OrangIndonesia {
private double Gaji;
public OrangJawa
(String nama, String alamat, String pekerjaan) {
super(nama, alamat, pekerjaan);
}
public double getGaji() {
return Gaji;
}
public void setGaji(double gaji) {
Gaji = gaji;
}
}

class OrangSumba extends OrangIndonesia {
private double Gaji;
public OrangSumba
(String nama, String alamat, String pekerjaan) {
super(nama, alamat, pekerjaan);
}

public double getGaji() {
return Gaji;
}
public void setGaji(double gaji) {
Gaji = gaji;
}

// Overloading Metoda
public String hitungTHR (double persen){

33
if (persen > 0.5)
return "THR terlalu besar!";
else return "THR tahun ini sebesar " +
persen * Gaji;
}

public String hitungTHR (int persen){
if (persen > 50) return "THR terlalu besar!";
else return "THR tahun ini sebesar " +
(persen * Gaji / 100);
}
}


Percobaan 5b. package OrangIndonesia class TestOrang

package OrangIndonesia;

public class TestOrang {
public static void main(String[] args) {
OrangIndonesia oi = new OrangIndonesia
("Adi", "Bandung", "Dosen");
System.out.println("Nama : " + oi.getNama());
System.out.println("Alamat : " + oi.getAlamat());
System.out.println
("Pekerjaan : " + oi.getPekerjaan() + "\n");

OrangJawa oj = new OrangJawa
("Monovan", "Jogja", "Dosen");
System.out.println("Nama : " + oj.getNama());
System.out.println("Alamat : " + oj.getAlamat());
System.out.println
("Pekerjaan : " + oj.getPekerjaan() + "\n");

OrangBatak ob = new OrangBatak
("Irwan", "Medan", "Dosen");
ob.setGaji(2000000);
System.out.println("Nama : " + ob.getNama());
System.out.println("Alamat : " + ob.getAlamat());
System.out.println("Pekerjaan : " + ob.getPekerjaan());
System.out.println("Gaji : Rp " + ob.getGaji() + "\n");


34
OrangSumba os = new OrangSumba
("Rocky", "Sumba", "Dosen");
os.setGaji(2000000);
System.out.println("Nama : " + os.getNama());
System.out.println("Alamat : " + os.getAlamat());
System.out.println("Pekerjaan : " + os.getPekerjaan());
System.out.println("Gaji : Rp " + os.getGaji());
System.out.println
("Keterangan : " + os.hitungTHR(30) + "\n");

OrangSumba osw = new OrangSumba
("Inneke", "Sumba", "Dosen");
osw.setGaji(2000000);
System.out.println("Nama : " + osw.getNama());
System.out.println("Alamat : " + osw.getAlamat());
System.out.println("Pekerjaan : " + osw.getPekerjaan());
System.out.println("Gaji : Rp " + osw.getGaji());
System.out.println
("Keterangan : " + osw.hitungTHR(0.75) + "\n");
}
}


Percobaan 6a. package rumahAna

package rumahAna;

public interface Alamat {
public abstract void aturNama();
public abstract void aturJalan ();
public abstract void aturKota ();
}


package rumahAna;
import rumahAna.Alamat;


public class Apartemen implements Alamat{
public void aturKota() {
System.out.println("Pekalongan.");


35
}
public void aturJalan() {
System.out.println("Jln. Hasanudin No. 8.");
}
public void aturNama() {
System.out.println("Namaku : Ana Mariana");
}
}


package rumahAna;

public class RumahAna {
public static void main(String[] args) {
Apartemen rmhAna = new Apartemen();
rmhAna.aturNama();
rmhAna.aturJalan();
rmhAna.aturKota();
}
}

5. Tugas Praktikum

1. Definisikan dengan bahasa Anda sendiri , istilah-istilah berikut ini :
Class
Object
Instantiate
Instance Variable
Instance Method
Class Variables atau static member variables
Constructor











36
MODUL 6
ARRAY, VECTOR DAN MATRIX

1. Tujuan

Mendeklarasikan dan membuat array, vector, matrix
Mengakses elemen-elemen di dalam array, vector, matrix
Menentukan jumlah elemen dalam sebuah array, vector, matrix


2. Dasar Teori

Array(larik) adalah variabel yang dapat menyimpan sebuah data list,
kemudian memanipulasinya dengan lebih efektif.
Matrix merupakan array multidimensi


3. Tugas Pendahuluan

1. Buatlah sebuah string array yang akan menginisialisasi 7 hari dalam
seminggu . Sebagai contoh

String days [ ] = {Monday, Tuesday...};
Gunakan while-loop, kemudian print semua nilai dari array (Gunakan juga
untuk do-while dan for-loop)


4. Praktikum

Percobaan 1. Program class LARIK

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

public class LARIK {
static int[] Larik = new int[25];
static int ukuranLarik;
public static void main(String[] args) {
System.out.print("Berapa ukuran larik? ");

37
ukuranLarik = inputData();
for (int j=0; j<ukuranLarik; j++){
System.out.print("Masukkan larik ke-" + (j+1) + " ");
Larik[j] = inputData();
}
MAX();
MIN();
AVERAGE();
}

private static void AVERAGE() {
double average = 0.0;
for (int avg=0;avg<ukuranLarik; avg++) {
average = average + Larik[avg];
}
average = average / ukuranLarik;
System.out.println("Rata-rata bilangan dalam larik = " +
average);
}

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;
}
private static void MIN() {
int minimum = Larik[0];
for (int min=0; min < ukuranLarik; min++){
if (minimum > Larik[min]) {
minimum = Larik[min];
}
}
System.out.println("Bilangan terkecil dalam larik = " +
minimum);
}

38

private static void MAX() {
int maximum = Larik[0];
for (int max=0; max < ukuranLarik; max++){
if (maximum < Larik[max]) {
maximum = Larik[max];
}
}
System.out.println("Bilangan terbesar dalam larik = " +
maximum);
}
}


Percobaan 2. Program Matriks

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


public class Matriks {
static int[][] Matriks1 = new int[10][10];
static int[][] Matriks2 = new int[10][10];
static int[][] MatriksHasil = new int[10][10];
static int ukuran;
public static void main(String[] args) {
System.out.print("Masukkan ukuran matriks : ");
ukuran = inputData();
bacaMatriks();
tambahkanMatriks();
tulisHasil();

}

private static void tulisHasil() {
System.out.println("\n\nMatrik Hasil Penjumlahan : ");
for (int i=0; i<ukuran; i++){
for (int j=0; j<ukuran; j++){
System.out.print(MatriksHasil[i][j] + " ");
}
System.out.println("");

39
}
}

private static void tambahkanMatriks() {
for (int i=0; i<ukuran; i++){
for (int j=0; j<ukuran; j++){
MatriksHasil[i][j] = Matriks1[i][j] + Matriks2[i][j];
}
}
}

private static void bacaMatriks() {
System.out.println("Masukkan data Matrik 1 : ");
for (int i=0; i<ukuran; i++){
for (int j=0; j<ukuran; j++){
System.out.print("Matriks["+(i+1)+"]["+(j+1)+"]");
Matriks1[i][j] = inputData();
}
}
System.out.println("Masukkan data Matrik 2 : ");
for (int i=0; i<ukuran; i++){
for (int j=0; j<ukuran; j++){
System.out.print("Matriks["+(i+1)+"]["+(j+1)+"] : ");
Matriks2[i][j] = inputData();
}
}
}

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;
}
}


40

Percobaan 3. Program class TestVector

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

public class TestVector {
static int ukuranVector;
static Vector<Integer> vector;

public static void main(String[] args) {
System.out.print("Berapa ukuran vector yang Anda mau? ");
ukuranVector = inputData();
buatVector();
bacaData();
tulisData();
}

// Metoda/fungsi untuk melakukan pembacaan.
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;
}

// Metoda/fungsi untuk membuat Vector.
private static void buatVector() {
vector = new Vector<Integer>(ukuranVector);
}

// Metoda/fungsi untuk membaca data dan
// memasukkannya ke Vector.
private static void bacaData() {

41
for (int i = 0; i < ukuranVector; i++) {
System.out.print("Masukkan data ke-" + (i + 1) + " ");
int data = inputData();
vector.add(data);
}
}

// Metoda/fungsi menulis isi vector secara terbalik.
private static void tulisData() {
for (int j = ukuranVector - 1; j >= 0; j--) {
System.out.println("Data ke " + (j + 1) + " = " +
vector.get(j));
}
}
}


5. Tugas Praktikum

1. Gunakanlah BufferedReader dan JOptionPane, Tanyakan pada user untuk
10 nomor. Kemudian gunakan array untuk menyimpan 10 nomor tersebut.
Tampilkan kepada user, input terbesar yang telah diberikan user
2. Berikut ini adalah array multidimensi yang menyatakan isi dari sebuah
buku alamat :

String entry = { {Florence, 735-1234,Manila},
{Joyce, 983-3333, Quezon City},
{Becca,456-3322, Manila}};

Cetak buku alamat tersebut dalam format berikut ini :

Name : Florence
Telp : 735-1234
Address : Manila

Name : Joyce
Telp : 983-3333
Address : Quezon City

Name : Becca
Telp : 456-3322
Address : Manila

42
MODUL 7
SORTING DAN SEARCHING


1. Tujuan

Mengorganisasikan data dengan cara mengurutkan
Mencari data-data yang telah terurut (sorted)


2. Dasar Teori

Pengurutan data dapat dilakukan secara urut naik (ascending) atau urut
turun (decending), keuntungan dari data terurut adalah kemudahan dalam
mencari data tertentu serta kemudahannya untuk dilakukan perbaikan,
disisipi data yang baru, dihapus dan digabungkan. Pengurutan data
terdapat beeberapa metode yaitu Bubble Sort, Selection Sort, Insertion
Sort, ShellSort, Quick Short
Pencarian elemen tertentu pada suatu vector yang telah terurut akan
menjadi lebih efektif dan cepat dibandingkan dengan melakukan
pencarian dalam vector yang belum terurut.


3. Tugas Pendahuluan

1. Jelaskan dan beri contoh pengurutan data menggunakan metode :
a. Bubble Sort
b. Selection Sort
c. Insertion Sort
d. ShellSort
e. Quick Short


4. Praktikum

Percobaan 1 . Pengurutan data

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

43
import java.util.Vector;

public class Data {
private static int ukuranVector;
private static Vector<Integer> vector;
private static boolean ketemu;

public static void main(String[] args) {

System.out.print("Berapa ukuran vector yang Anda mau? ");
ukuranVector = inputData();
buatVector();
bacaData();
pengurutan();
tulisData();
System.out.println("Apakah Anda mau melakukan pencarian? ");
System.out.print("Jika ya, masukkan data yang Anda cari, jika
tidak ketik -99 : ");
int cari = inputData();
if (cari != -99)
cariData(cari);
else
System.out.println("Anda tidak mencari apa-apa.
Thanks.");
}

private static void cariData(int cari) {
System.out.println("Metoda apa yang akan digunakan untuk
pencarian? ");
System.out.println("1. Array Search");
System.out.println("2. Binary Search");
System.out.print("3. Vector Search (Masukkan pilihan Anda) :
");
int metoda = inputData();
if (metoda == 3) {
VectorSearch cnv = new VectorSearch();
ketemu = cnv.Search(cari);
if (ketemu) {
System.out.println("Data yang Anda cari " + cari
+ " ada di index Vector " + cnv.getHasil());
} else {
System.out.println("Data yang Anda cari " + cari

44
+ " tidak ada di Vector. ");
}
} else if (metoda == 2) {
Binary bnr = new Binary();
ketemu = bnr.Search(cari);
if (ketemu) {
System.out.println("Data yang Anda cari " + cari
+ " ada di index Vector " + bnr.getHasil());
} else {
System.out.println("Data yang Anda cari " + cari
+ " tidak ada di Vector. ");
}
} else {
ArraySearch ars = new ArraySearch();
ketemu = ars.Search(cari);
if (ketemu) {
System.out.println("Data yang Anda cari " + cari
+ " ada di index Vector " + ars.getHasil());
} else {
System.out.println("Data yang Anda cari " + cari
+ " tidak ada di Vector. ");
}
}
}

private static void pengurutan() {
int pilihan;
System.out.println("Metoda pengurutan apa yang akan
digunakan? ");
System.out.println("1. BUBBLE SORT");
System.out.println("2. SELECTION SORT");
System.out.println("3. INSERTION SORT");
System.out.println("4. SHELL SHORT");
System.out.print("5. QUICK SORT (Masukkan nilai pilihan) :
");
pilihan = inputData();
if (pilihan == 1)
vector.addAll(Bubble.Sort(vector));
else if (pilihan == 2)
vector.addAll(Selection.Sort(vector));
else if (pilihan == 3)
vector.addAll(Insertion.Sort(vector));

45
else if (pilihan == 4)
vector.addAll(Shell.shellSort(vector));
else if (pilihan==5)
vector.addAll(Quick.quickSort(vector));
}

// Metoda/fungsi untuk melakukan pembacaan.
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;
}

// Metoda/fungsi untuk membuat Vector.
private static void buatVector() {
vector = new Vector<Integer>(ukuranVector);
}

// Metoda/fungsi untuk membaca data dan
// memasukkannya ke Vector.
private static void bacaData() {
int data;
for (int i = 0; i < ukuranVector; i++) {
System.out.print("Masukkan data ke-" + (i + 1) + " : ");
data = inputData();
vector.add(data);
}
}

// Metoda/fungsi menulis isi vector.
private static void tulisData() {
System.out.println("\nData setelah diurutkan : ");
for (int j = 0; j < ukuranVector; j++) {
System.out.println("Data ke " + (j + 1) + " = " +
vector.get(j));

46
}
}

public static int getUkuranVector() {
return ukuranVector;
}

public static Vector<Integer> getVector() {
return vector;
}
}

Percobaan 2. Pengurutan dengan metoda Bubble Sort

import java.util.Vector;

public class Bubble {
static Vector<Integer> vectorBubble;

public static Vector<Integer> Sort(Vector<Integer> vectorBubble) {
int n = 0;
int ukuran = Data.getUkuranVector();
while (n < ukuran) {
for (int i = 1; i < ukuran; i++) {
if (vectorBubble.get(i - 1) >
vectorBubble.get(i)) {
int temp = vectorBubble.get(i);
vectorBubble.set(i, vectorBubble.get(i
- 1));
vectorBubble.set(i - 1, temp);
}
}
n++;
}
return vectorBubble;
}
}

Percobaan 3. Pengurutan dengan metoda Selection Sort

import java.util.Vector;


47
public class Selection {
public static Vector<Integer> Sort(Vector<Integer> vectorSelection) {
int i;
int ukuran = Data.getUkuranVector();
int max;
while (ukuran > 0){
max = 0;
for(i=1; i<ukuran; i++){
if (vectorSelection.get(max) <
vectorSelection.get(i)) {
max = i;
}
}
int temp = vectorSelection.get(max);
vectorSelection.set(max, vectorSelection.get(ukuran-
1));
vectorSelection.set(ukuran-1, temp);
ukuran--;
}
return vectorSelection;
}
}

Percobaan 4. Pengurutan dengan metoda Insertion Sort

import java.util.Vector;

public class Insertion {
public static Vector<Integer> Sort(Vector<Integer> vectorInsertion) {
int i=1;
int index;
int ukuran = Data.getUkuranVector();
while (i<ukuran){
int temp=vectorInsertion.get(i);
for(index=i; index>0; index--){
if (temp < vectorInsertion.get(index-1)){
vectorInsertion.set(index,
vectorInsertion.get(index-1));
}
else break;
}
vectorInsertion.set(index, temp);

48
i++;
}
return vectorInsertion;
}
}

Percobaan 5. Pengurutan dengan Metoda Shell Sort
import java.util.Vector;

public class Shell {

static int N;
static int distance;
static int j;
static int i;
static Vector<Integer> vectorShell;

public static Vector<Integer> shellSort(Vector<Integer> vectorShell) {
N = Data.getUkuranVector();
distance = N / 2;
while (distance > 0) {
for (i = 0; i < N - distance; i++) {
j = i + distance;
if (vectorShell.get(i) > vectorShell.get(j)) {
int temp = vectorShell.get(i);
vectorShell.set(i, vectorShell.get(j));
vectorShell.set(j, temp);
}
}
distance = distance / 2;
}
return vectorShell;
}
}

Percobaan 6. Pengurutan dengan Metode Quick Sort
import java.util.Vector;

public class Quick {

private static void swap(Vector<Integer> vectorQuick, int left, int right) {
int temp = vectorQuick.get(left);

49
vectorQuick.set(left, vectorQuick.get(right));
vectorQuick.set(right, temp);
}

public static Vector<Integer> quickSort(Vector<Integer> vectorQuick) {
int ukuran = Data.getUkuranVector() - 1;
quickSortRecursive(vectorQuick, 0, ukuran);
return vectorQuick;
}

private static void quickSortRecursive(Vector<Integer> vectorQuick,
int left, int right) {
int pivot;
if (left >= right)
return;
pivot = partition(vectorQuick, left, right);
quickSortRecursive(vectorQuick, left, pivot - 1);
quickSortRecursive(vectorQuick, pivot + 1, right);
}

public static int partition(Vector<Integer> vectorQuick, int left, int right)
{
while (true) {
while ((left < right)
&& (vectorQuick.get(left) <
vectorQuick.get(right)))
right--;
if (left < right)
swap(vectorQuick, left, right);
else
return left;
while ((left < right)
&& (vectorQuick.get(left) <
vectorQuick.get(right)))
left++;
if (left < right)
swap(vectorQuick, left, right--);
else
return right;
}
}
}

50

Percobaan 7. Pencarian dengan Array Search

import java.util.Vector;

public class ArraySearch {

int hasil;
boolean ketemu = false;
private Vector<Integer> vectorArs;

public boolean Search(int cari) {
new Data();
int batas = Data.getUkuranVector();
vectorArs = new Vector<Integer>(batas);
vectorArs.addAll(Data.getVector());
int[] ArySearch = new int[batas];
for (int i = 0; i < (batas - 1); i++) {
ArySearch[i] = vectorArs.get(i);
}
int index = 0;
int value;
while ((!ketemu) && (index < batas)) {
value = ArySearch[index];
if (cari == value) {
ketemu = true;
hasil = index;
break;
}
index++;
}
return ketemu;
}

public int getHasil() {
return hasil + 1;
}

}

Percobaan 8. Pencarian Binary Search


51
import java.util.Vector;

public class Binary {

int hasil;
boolean ketemu = false;
private Vector<Integer> vectorBnr;

public boolean Search(int cari) {
new Data();
int ukuran = Data.getUkuranVector();
vectorBnr = new Vector<Integer>(ukuran);
vectorBnr.addAll(Data.getVector());
int[] ArrayBinary = new int[ukuran];
for (int i = 0; i < (ukuran -1); i++) {
ArrayBinary[i] = vectorBnr.get(i);
}
int low = 0;
int high = Data.getUkuranVector()-1;
int mid = (low + high) / 2;
int midValue;
while (low < high) {
midValue = ArrayBinary[mid];
if (midValue == cari) {
ketemu = true;
hasil = mid;
break;
} else {
if (cari > midValue)
low = mid + 1;
else
high = mid;
}
mid = (low + high) / 2;
}
return ketemu;
}

public int getHasil() {
return hasil + 1;
}
}

52

Percobaan 9. Pencarian Vector Search

import java.util.Vector;

public class VectorSearch {
int hasil;
boolean ketemu = false;
private Vector<Integer> vectorCv;

public boolean Search(Integer cari) {
new Data();
vectorCv = new Vector<Integer>(Data.getUkuranVector());
vectorCv.addAll(Data.getVector());
if (vectorCv.contains(cari)) {
hasil = vectorCv.indexOf(cari) + 1;
}
return ketemu = true;
}
public int getHasil() {
return hasil;
}
}

5. Tugas Praktikum


1. Buat program dengan inputan NIM (empat digit terakhir), nama, dan
fakultas untuk beberapa mahasiswa, kemudian lakukan sorting terhadap
inputan berdasarkan NIMnya!
2. Buat sebuah program database pabrik, merk, CC dan harga sepeda motor
kemudian hasil tersebut bisa diurutkan berdasarkan harga dan CCnya
(secara ascending dan descending)!
Misal:
Yamaha >> Mio >> 135CC >> 12.000.000
Honda >> Revo >> 100CC >> 13.000.000
Viar >> ViarX >> 125CC >> 7.000.000


53
MODUL 8
STACK, QUEUE, COLLECTIONS,ARRAYLIST, SET


1. Tujuan

Memahami Abstrak Data Type (ADT) Statis yaitu Stack, Queue,
Collections, ArrayList dan Set


2. Dasar Teori

Stack (Tumpukan) dapat dibayangkan sebagai suatu keranjang dimana
hanya dat terakhir yang dapat diperoleh kembali dengan satu langkah.
Data di bawah hanya dapat diambil jika data di sebelah atasnya telah
diambil (dikeluarkan) terlebih dahulu, sehingga struktur data ini dapat
dikatakan LIFO (Last In First out).
Queue (antrian) apada kenyataannya misal dijumpai pada antrian karcis
untuk membeli tiket, berlaku konsep FIFO (First In First Out).


3. Tugas Pendahuluan

1. Jelaskan apa yang dimaksud dengan
a. Stack
b. Queue
c. Collection
d. ArrayList
e. Set

4. Praktikum

Percobaan 1. Program Tumpukan (Stack)
package myStack;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;

public class Tumpukan {

54
private static Stack<Integer> stack;
private static int ukuran;

public static void main(String[] args) {
System.out.print("Berapa ukuran STACK diinginkan? ");
ukuran = inputData();
buatStack();
bacaData();
tulisData();
}

private static void tulisData() {
System.out.println("Isi Stack adalah (menggunakan prosedur
POP) : " );
int dataStack;
for (int i = 0; i < ukuran; i++) {
dataStack = stack.pop();
System.out.println ("Nilainya = " + dataStack);
}
}

private static Integer 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;

}

private static void bacaData() {
int data;
System.out.println("Masukkan nilai-nilai STACK : ");
for (int i = 0; i < ukuran; i++) {
System.out.print("Data ke-" + (i + 1) + " : ");
data = inputData();

55
stack.push(data);
}

}

private static void buatStack() {
stack = new Stack<Integer>();
}
}

Percobaan 2. Solusi Rekursif untuk Stack
package myStack;
// Parameter-parameter yang akan disimpan di stack.
public class Params {
int n;
int codePart;
int returnAddress;
Params(int nn, int ra)
{
n=nn;
returnAddress = ra;
}
} // end class Params
package myStack;

public class StackX
{
int maxSize; // Ukuran array stack.
Params[] stackArray;
int top; // Bagian atas (top) stack

//-------------------------------------------------------------
public StackX(int s) {
maxSize = s; // Mengatur ukuran array.
stackArray = new Params[maxSize]; // Membuat array.
top = -1; // Saat stack kosong.
}

//-------------------------------------------------------------
// Menaruh item di atas stack.
public void push(Params p)
{

56
// Melakukan penambahan top; menyisipkan item.
stackArray[++top] = p;
}

//-------------------------------------------------------------
// Mengambil item dari bagian atas (top) stack.

public Params pop()
{
// Mengakses item, mengurangi nilai top.
return stackArray[top--];
}

//-------------------------------------------------------------
// Melihat item di bagian atas stack.
public Params peek()
{
return stackArray[top];
}
//-------------------------------------------------------------
} // end class StackX

package myStack;

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


public class StackTriangleApp
{
static int theNumber;
static int theAnswer;
static StackX theStack;
static int codePart;
static Params theseParams;

public static void main(String[] args)
throws IOException
{
System.out.print
("Masukkan bilangan segitiga Phytagoras : ");

57
System.out.flush();
theNumber = getInt();
recTriangle();
System.out.println
("Bilangan segitiga Phytagoras = "+ theAnswer);
} // Akhir metoda/fungsi main()

// -------------------------------------------------------------
public static void recTriangle()
{
theStack = new StackX(50);
codePart = 1;
// Memanggil metoda step() hingga bernilai true.
while( step() == false)
// Pernyataan kosong.
;
}

// -------------------------------------------------------------
public static boolean step()
{
switch(codePart)
{
case 1: // Pemanggilan awal.
theseParams = new Params(theNumber, 6);
theStack.push(theseParams);
codePart = 2;
break;
case 2: // Jalan masuk metoda.
theseParams = theStack.peek();
if(theseParams.n == 1) // Pengujian.
{
theAnswer = 1;
codePart = 5; // Keluar (exit).
}
else
codePart = 3; // Pemanggilan rekursif.
break;
case 3: // Pemanggilan metoda.
Params newParams =
new Params(theseParams.n - 1, 4);
theStack.push(newParams);

58
codePart = 2; // Masuk ke metoda.
break;
case 4: // Perhitungan.
theseParams = theStack.peek();
theAnswer = theAnswer + theseParams.n;
codePart = 5;
break;
case 5: // Keluar (exit) metoda.
theseParams = theStack.peek();
codePart = theseParams.returnAddress; // (4 atau 6)
theStack.pop();
break;
case 6: // Titik kembali.
return true;
} // end switch

return false; // Semua kecuali 7
} // end triangle

// -------------------------------------------------------------
public static String getString() throws IOException
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}

// -------------------------------------------------------------

public static int getInt() throws IOException
{
String s = getString();
return Integer.parseInt(s);
}
// -------------------------------------------------------------
} // end class StackTriangleApp


// stackTriangle.java
// Mengevaluasi segitiga Phytagoras, stack menggantikan rekursion.


59
Percobaan 3. Program simulasi Stack dengan teknik Rekursif

package myStack;
public class StackX2 {
int maxSize; // Ukuran array stack.
int[] stackArray;
int top; // Bagian atas (top) stack

StackX2(int s) // constructor
{
maxSize = s;
stackArray = new int[maxSize];
top = -1;
}

// Meletakkan item ke bagian atas (top) stack.
public void push(int p) {
stackArray[++top] = p;
}

// Mengambil item dari bagian atas (top) stack.
public int pop() {
return stackArray[top--];
}

// Melihat item dari bagian atas (top) stack.
public int peek() // peek at top of stack
{
return stackArray[top];
}

// Menguji apakah stack kosong.
public boolean isEmpty() {
return (top == -1);
}

} // end class StackX

package myStack;

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

60
import java.io.InputStreamReader;

public class StackTriangleApp2 {
static int theNumber;
static int theAnswer;
static StackX2 theStack;

public static void main(String[] args) throws IOException {
System.out.print("Masukkan bilangan : ");
System.out.flush();
theNumber = getInt();
stackTriangle();
System.out.println("Bilangan segitiga Phytagoras = " +
theAnswer);
} // end main()

// -------------------------------------------------------------
public static void stackTriangle() {
theStack = new StackX2(10000); // Membuat stack
theAnswer = 0; // Menginisialisasi theAnswer
while (theNumber > 0) // Hingga n bernilai 1,
{
theStack.push(theNumber); // Memasukkan nilai.
--theNumber; // Mengurangi nilai.
}
while (!theStack.isEmpty()) // Hingga stack kosong,
{
int newN = theStack.pop(); // Mengeluarkan (pop) nilai,
theAnswer += newN; // Menambah nilai theAnswer
}
}

// -------------------------------------------------------------
public static String getString() throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}

// -------------------------------------------------------------
public static int getInt() throws IOException {

61
String s = getString();
return Integer.parseInt(s);
}
}

Percobaan 4. Queue (Antrian)
package queue;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;

public class Antrian {
private static int ukuran;
private static Queue<Integer> queue;

public static void main(String[] args) {
System.out.print("Berapa ukuran QUEUE diinginkan? ");
ukuran = inputData();
buatQueue();
bacaData();
tulisData();

}

private static void buatQueue() {
queue = new LinkedList<Integer>();
}

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;
}

62

private static void tulisData() {
Integer data;
System.out.println("\nUrutan keluar elemen dari QUEUE : ");
for (int i = 0; i < ukuran; i++) {
data = queue.remove();
System.out.println("Data ke-" + (i + 1) + " : " + data);
}
data = queue.size();
System.out.println("Ukuran QUEUE sekarang adalah " + data);
}

private static void bacaData() {
Integer data;
for (int i = 0; i < ukuran; i++) {
System.out.print("Data ke-" + (i + 1) + " : ");
data = inputData();
queue.add(data);
}
data = queue.size();
System.out.println("Ukuran QUEUE sekarang adalah " + data);
}
}

Percobaan 5. Sorting pada kelas Collection dan antarmuka comparable
package collection;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class Koleksi {
private static int ukuran;
private static Collection <String> cs;
private static String stringInput;

public static void main(String[] args) {
cs = new LinkedList<String>();

63
System.out.print("Berapa ukuran COLLECTION diinginkan? ");
ukuran = inputData();
for (int i=0; i<ukuran; i++) {
System.out.print
("Data ke-" + (i+1) + " (Masukkan string) : ");
stringInput = bacaData();
cs.add(stringInput);
}
tulisData();
}

private static void tulisData() {
Collections.sort((List<String>) cs);
Iterator<String> it = cs.iterator();
System.out.println("\nDATA TERURUT DALAM
COLLECTION : ");
while(it.hasNext()) {
System.out.println("Data : " + it.next());
}
}

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;
}

private static String bacaData() {
String data = null;
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in));
String stringInput = null;
try {
stringInput = bfr.readLine();
} catch (IOException e) {

64
e.printStackTrace();
}
data = String.valueOf(stringInput);
return data;
}
}
Percobaan 6. ArrayList
package bynary_and_ArraySearchList;
import java.util.*;

public class Insert_ArrayList_LinkedList {
static final int N = 50000;

// Mencatat waktu yang diperlukan untuk menyisipkan
// sejumlah N objek ke List.

static long timeList(List<Object> lst) {
long start = System.currentTimeMillis();
Object obj = new Object();
for (int i = 0; i < N; i++) {
lst.add(0, obj);
}
return System.currentTimeMillis() - start;
}

public static void main(String args[]) {
// Perhitungan waktu untuk ArrayList
System.out.println("Time for ArrayList = "
+ timeList(new ArrayList<Object>()));
// Perhitungan waktu LinkedList
System.out.println("Time for LinkedList = "
+ timeList(new LinkedList<Object>()));
}
}

Percobaan 7. Binary Search Array List
package bynary_and_ArraySearchList;

import java.util.*;

public class BinarySearchArrayList {
static final int N = 10000;

65
static List<Integer> values;

// Membuat nilai-nilai bilangan bulat acak sebanyak N.
static {
Integer vals[] = new Integer[N];
Random rn = new Random();
for (int i = 0, currval = 0; i < N; i++) {
vals[i] = new Integer(currval);
currval += rn.nextInt(100) + 1;
System.out.println
("Data ke-" + (i+1) + " adalah " + currval);
}
values = Arrays.asList(vals);
}
// Beriterasi sepanjang list dan mencari nilai tertentu
// menggunakan metoda Binary Search.

static long timeList(List<Integer> lst) {
long start = System.currentTimeMillis();
for (int i = 0; i < N; i++) {
// Mencari nilai tertentu menggunakan metoda Binary
Search.
int indx = Collections.binarySearch(lst, values.get(i));
// Jika terjadi kesalahan saat pencarian.
if (indx != i) {
System.out.println("*** error ***\n");
}
}
return System.currentTimeMillis() - start;
}

public static void main(String args[]) {
// Pencarian pada ArrayList
System.out.println("Waktu diperlukan pada pencarian ArrayList
= "
+ timeList(new ArrayList<Integer>(values)) +
" mikrodetik.");
// Pencarian pada LinkedList
System.out.println("Waktu diperlukan pada pencarian LinkedList
= "
+ timeList(new LinkedList<Integer>(values))
+ " mikrodetik."); } }

66

5. Tugas Praktikum

1. Buatlah program kalkulator sederhana (pengoperasian 2 bilangan
aritmatika sederhana)!
Operasi aritmatika tersebut (dalam notasi infiks), harus diubah kedalam
bentuk notasi postfiks.

Contoh:
INFIKS POSTFIKS
3 + 7 3 7 +
2 9 2 9 -
8 * 7 8 7 *
9 / 3 9 3 /

Misal : algoritma 3 7 +

indeks Stack process
2 + add
1 7 push operand
0 3 push operand














67
MODUL 9
SINGLY LINKED LIST & DOUBLY LINKED LIST


1. Tujuan

Mendeklarasikan dan membuat linked list
Memahami implementasi berbagai macam linked list


2. Dasar Teori

Senarai berantai dapat diilustrasikan seperti satu kesatuan rangkaian
kereta api. Kereta api terdiri dari beberapa gerbong, masing-masing dari gerbong
itulah yang disebut struct / tipe data bentukan. Agar gerbong-gerbong
tersebut dapat saling bertaut dibutuhkan minimal sebuah kait yang
dinamakan sebagai pointer.
Setelah mendeklarasikan tipe data dan pointer pada list, selanjutnya kita
akan mencoba membuat senarai / linked list tunggal tidak berputar atau sebuah
gerbong. Ada beberapa operasi yang dapat kita buat pada senarai tersebut,
diantaranya: tambah, hapus dan edit dari gerbong tersebut.
Inti dari linked list adalah proses (tambah, edit, hapus) dari gerbong / node dan
bagaimana rnenyambungkan antar gerbong / node tersebut.

Gambar diatas dilustrasikan sebuah rangkaian kereta api dengan 4 buah
gerbong. Gerbong A akan disebut sebagai kepala / head (walaupun penamaan ini
bebas) dan gerbong D adalah ekor / tail. Tanda panah merupakan kait atau
pointer yang menghubungkan satu gerbong dengan yang lainnya.
Pointer yang dimiliki D menuju ke NULL,inilah yang membedakan antara
senarai berputar dengan yang tidak berputar. Kalau senarai berputar maka pointer
dari D akan menuju ke A lagi.
PEMBENTUKAN NODE (GERBONG)
Digunakan keyword new yang berarti mempersiapkan sebuah node baru
berserta alokasi memorinya, kemudian node tersebut diisi data dan pointer nextnya
ditunjuk ke NULL. Pembentukan node tidak dapat dilakukan sekaligus namun
harus satu persatu, hal ini berkaitan dengan bagaimana cara menyambungkan antar
node tersebut.

68

kepala= new Gerbong; //membuat sebuah node dengan nama kepala
kepala->next==NULL; //pointer milik kepala diarahkan ke NULL
kepal a- >dat a=101; //isi field data dengan 101

Kode diatas apabila dicompile maka akan membentuk sebuah node bertipe
Gerbong dengan nama kepala. Karena bertipe list maka kepala juga memiliki 2
field seperti list yaitu field data dan field next. Bila diasumsikan dengan gerbong
maka pada proses ini dibentuk gerbong A.

Setelah membentuk sebuah node dengan nama kepala, maka
langkah selanjutnya adalah membentuk gerbong yang lain (gerbong B dan
selanjutnya).
baru=new Gerbong; //membuat sebuah node dengan nama baru
baru->data=5;

//Tambah Depan
if (kepala->next==NULL)
{
baru-->next=kepala; //menyambung node baru dengan node kepala
kepala=baru; //memindahkan kepala ke node baru
}
//Tambah Belakang
ekor- >next =baru; //menyambung node paling akhir/ekor ke node baru
ekor=baru; //meniindahkan ekor ke node terakhir yaitu node baru .
ekor->next=NULL;

Tambah belakang berarti node baru yang terbentuk akan diletakan di posisi paling
belakang.
PENGHAPUSAN NODE
Pada senarai berkepala, penghapusan sebuah list dilakukan jika ada list lain
yang bukan list "kepala" dalam barisan senarai tersebut. Dengan kata lain, list yang
digunakan sebagai "kepala" tidak boleh dihapus, "kepala harus dipindahkan terlebih
dahulu. Keyword yang digunakan adalah delete. Contoh:
//Hapus Depan



69


if(kepala->next!=NULL)
{ if(kepala->next==ekor)
{ hapus=kepala;
kepala=kepala->next;
delete hapus;
}
}
else
{
kepala=NULL;
}


//Hapus Belakang

if(head->next!=NULL)
{
bantu=kepala;
while(bantu->next->next!=NULL)
{ bantu=bantu->next;
}
hapus=bantu->next;
bantu->next = NULL;
delete hapus;
}
else
{
head =NULL;
}



70

MENAMPILKAN ISI NODE

Untuk menampilkan isi suatu node dengan cara mengakses field yang ada di dalam
node tersebut. Yaitu dengan Contoh :
bantu =head;
while(bantu!=NULL)
{
print(%i ,bantu->data);
bantu=bantu->next;
}


3. Tugas Pendahuluan

1. Apa yang dimaksud dengan List (Senarai)
2. Jelaskan perbedaan Singly Linked List (Senarai Berkait Tunggal) dan
Doubly Linked List (Senarai berkait Ganda)

4. Praktikum

Percobaan 1. Sinlge Link List
package defaultSinglyLinkedList;
import singlyLinkedList.pOneChildNode;

public class pLinkedList{
protected pOneChildNode head;
protected int number;

public pLinkedList(){
head = null;
number = 0;
}
public boolean isEmpty(){
return head == null;
}
public int size(){
return number;
}
public void insert(Object obj){
head = new pOneChildNode(obj,head);
number++;

71
}
public Object remove(){
if(isEmpty())
return null;
pOneChildNode tmp = head;
head = tmp.getNext();
number--;
return tmp.getData();
}
public void insertEnd(Object obj){
if(isEmpty())
insert(obj);
else{
pOneChildNode t = head;
while(t.getNext() != null)
t=t.getNext();
pOneChildNode tmp =
new pOneChildNode(obj,t.getNext());
t.setNext(tmp);
number++;
}
}
public Object removeEnd(){
if(isEmpty())
return null;
if(head.getNext() == null)
return remove();
pOneChildNode t = head;
while(t.getNext().getNext() != null)
t = t.getNext();
Object obj = t.getNext().getData();
t.setNext(t.getNext().getNext());
number--;
return obj;
}
public Object peek(int n){
pOneChildNode t = head;
for(int i = 0;i<n && t != null;i++)
t = t.getNext();
return t.getData();
}
}

72

Percobaan 2. Single Link List
package defaultSinglyLinkedList;
import java.util.LinkedList;

public class SenaraiBerkaitTunggal {
private static LinkedList<Integer> l;
public static void main(String[] args) {
System.out.println("Program menggunakan kelas LINKEDLIST
default bahasa Java.");
l = new LinkedList<Integer>();
Integer j = null;
int i;
System.out.println("starting...");
for (i = 0; i < 5; i++) {
j = new Integer((int) (Math.random() * 100));
l.addFirst(j);
System.out.println("add : " + j);
}
for (; i < 10; i++) {
j = new Integer((int) (Math.random() * 100));
l.addLast(j);
System.out.println("addLast : " + j);
}
for (i = 0; i < l.size(); i++)
System.out.println("get " + i + " : " + l.get(i));
for (i = 0; i < 5; i++)
System.out.println("remove : " + ((Integer) l.remove()));
while (!l.isEmpty())
System.out.println("removeLast : " + ((Integer)
l.removeLast()));
System.out.println("Done ;-)");
}
}

Percobaan 3. Single Linked List
package singlyLinkedList;
public class pOneChildNode{
protected Object data;
// next merupakan pointer ke node berikutnya.
protected pOneChildNode next;


73
// Konstruktor 1.
public pOneChildNode(){
next = null;
data = null;
}
// Konstruktor 2.
public pOneChildNode(Object d,pOneChildNode n){
data = d;
next = n;
}
// Pengaturan nilai pointer next.
public void setNext(pOneChildNode n){
next = n;
}
// Pengaturan nilai data.
public void setData(Object d){
data = d;
}
// Mengambil nilai pointer next.
public pOneChildNode getNext(){
return next;
}
// Mengambil nilai data yang tersimpan dalam Node.
public Object getData(){
return data;
}
// Mengubah nilai data ke bentuk String.
public String toString(){
return ""+data;
}
}

Percobaan 4. Single Link List
package singlyLinkedList;
import defaultSinglyLinkedList.pLinkedList;


public class TestLinkedList {
public static void main(String[] args){
pLinkedList l = new pLinkedList();
Integer j = null;
int i;

74
System.out.println("starting...");
for(i=0;i<5;i++){
j = new Integer((int)(Math.random() * 100));
l.insert(j);
System.out.println("insert: " + j);
}
for(;i<10;i++){
j = new Integer((int)(Math.random() * 100));
l.insertEnd(j);
System.out.println("insertEnd: " + j);
}
for(i=0;i<l.size();i++)
System.out.println("peek "+i+": "+l.peek(i));
for(i=0;i<5;i++)
System.out.println("remove: " + ((Integer)l.remove()));
while(!l.isEmpty())
System.out.println("removeEnd: " + ((Integer)l.removeEnd()));
System.out.println("Done ;-)");
}


}

Percobaan 5. Double Linked List
package doublyLinkedList;

import java.lang.String;
import java.util.*;

public class pDoublyLinkedList {

private pTwoChildNode head, tail;
protected long num;

protected pTwoChildNode getHead() {
return head;
}

protected pTwoChildNode getTail() {
return tail;
}


75
protected void setHead(pTwoChildNode p) {
head = p;
}

protected void setTail(pTwoChildNode p) {
tail = p;
}

public pDoublyLinkedList() {
setHead(new pTwoChildNode());
setTail(new pTwoChildNode());
getTail().setLeft(head);
getHead().setRight(tail);
num = 0;
}

public long size() {
return num;
}

public boolean isEmpty() {
return num == 0;
}

public void addHead(String o) {
pTwoChildNode p = new pTwoChildNode(o);
p.setLeft(getHead());
p.setRight(getHead().getRight());
getHead().setRight(p);
p.getRight().setLeft(p);
num++;
}

public Object removeHead() {
Object o = null;
if (!isEmpty()) {
pTwoChildNode p = getHead().getRight();
getHead().setRight(p.getRight());
p.getRight().setLeft(getHead());
o = p.getData();
num--;
}

76
return o;
}

public void addTail(String o) {
pTwoChildNode p = new pTwoChildNode(o);
p.setRight(getTail());
p.setLeft(getTail().getLeft());
getTail().setLeft(p);
p.getLeft().setRight(p);
num++;
}

public Object removeTail() {
Object o = null;
if (!isEmpty()) {
pTwoChildNode p = getTail().getLeft();
getTail().setLeft(p.getLeft());
p.getLeft().setRight(getTail());
o = p.getData();
num--;
}
return o;
}

public void add(String o) {
addHead(o);
}

public Object remove() {
return removeHead();
}

public Enumeration<Object> elementsHeadToTail() {
return new Enumeration<Object>() {

pTwoChildNode p = getHead();

public boolean hasMoreElements() {
return p.getRight() != getTail();
}

public Object nextElement() {

77
synchronized (pDoublyLinkedList.this) {
if (hasMoreElements()) {
p = p.getRight();
return p.getData();
}
}
throw new NoSuchElementException(
"pDoublyLinkedList
Enumeration");
}
};
}

public Enumeration<Object> elementsTailToHead() {
return new Enumeration<Object>() {

pTwoChildNode p = getTail();

public boolean hasMoreElements() {
return p.getLeft() != getHead();
}

public Object nextElement() {
synchronized (pDoublyLinkedList.this) {
if (hasMoreElements()) {
p = p.getLeft();
return p.getData();
}
}
throw new NoSuchElementException(
"pDoublyLinkedList
Enumeration");
}
};
}

}

Percobaan 6. Doubly Linked List
package doublyLinkedList;
public class pTwoChildNode {
protected String data;

78
protected pTwoChildNode left, right;

public pTwoChildNode() {
data = null;
left = right = null;
}

public pTwoChildNode(String d) {
data = d;
left = right = null;
}

public void setLeft(pTwoChildNode l) {
left = l;
}

public void setRight(pTwoChildNode r) {
right = r;
}

public void setData(String d) {
data = d;
}

public pTwoChildNode getLeft() {
return left;
}

public pTwoChildNode getRight() {
return right;
}

public Object getData() {
return data;
}

public String toString() {
return "" + data;
}
}

Percobaan 7. Doubly Linked List

79
package doublyLinkedList;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Enumeration;

public class TestDoublyLinkedList {

private static pDoublyLinkedList list;

public static void main(String[] args) {
list = new pDoublyLinkedList();
System.out.println("PROGRAM DOUBLY LINKED LIST : ");
System.out.print("Ada berapa data? ");
int cacahData = inputData();
String data;
for(int i=1;i<=cacahData;i++){
System.out.print("Masukkan kalimat Anda : ");
data = bacaData();
masukList(data);
}
isiList();
}
private static Integer 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;

}
private static void isiList() {
System.out
.print("Mau tulis dari belakang-depan (1) atau
depan-belakang (9) : ");
int kendali = inputData();

80
System.out.println("Isi list :");
if (kendali == 1) {
int i = 1;
Enumeration<Object> e = list.elementsHeadToTail();
while (e.hasMoreElements())
System.out.println("Kalimat " + (i++) + " : " +
((String) e.nextElement())
+ " ");
}
if (kendali == 9) {
int i = 1;
Enumeration<Object> e = list.elementsTailToHead();
while (e.hasMoreElements())
System.out.println("Kalimat " + (i++) + " : " +
((String) e.nextElement())
+ " ");
}
}

private static void masukList(String data) {
list.addHead(data);
}

private static String bacaData() {
String data = null;
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in));
String stringInput = null;
try {
stringInput = bfr.readLine();
} catch (IOException e) {
e.printStackTrace();
}
data = String.valueOf(stringInput);
return data;
}}

5. Tugas Praktikum


1. Buatlah sebuah linked list non circular yang berisi nim anda dan nama
lengkap anda.

81
2. Buat fungsi untuk menambahkan node single linked list non circular dimana
tiap node mengandung informasi nim dan nama. Peletakan posisi node
urut berdasar nim secara ascending, jadi bisa tambah depan, belakang
maupun tambah di tengah.
Isikan data nim dan nama lengkap teman sebelah kiri dan kanan anda!!!
3. Buatlah fungsi untuk menampilkan data 3 buah node yang telah anda bentuk
sebelumnya. Contoh tampilan
NIM Nama Lengkap
04511012 Adi Hendrawan
04511019 Januar Priya
04511028 Anggraeni
4. Buatlah fungsi untuk mencari nama yang telah diinputkan dengan
menggunakan NIM.
Contoh tampilan:
Inputkan nim yang dicari = 04511028
Nama yang tercantum Anggraeni
5. Buatlah sebuah fungsi untuk menghapus nim yang diinputkan oleh user.
Contoh tampilan:
NIM yang mau dihapus = 04511028
NIM dengan nama Anggraeni ditemukan dan telah dihapus
6. Buatlah sebuah program dengan menggunakan single linked list non circular
dengan fungsi-fungsi:
menambah data(dari depan dan dari belakang)
search data yang telah diinputkan
menghapus data( dari depan dan dari belakang)
mencetak data
Buat dengan menggunakan menu ya..
7. (soal extended) Dengan menggunakan soal no 6 tambahkan 4 fungsi
tambahan:
menambah data(di tengah)
menghapus data tertentu(berada di tengah)
mengurutkan data acak secara acending
mengurutkan data acak secara decending

82
MODUL 10
TREE

1. Tujuan

Memahami Konsep dasar Tree
Mangimplementasikan Binary Tree pada Java
Melakukan penelusuran pada Binary Tree
Memahami dan mengimplementasikan AVL Tree, Red Black Tree, B-Tree


2. Dasar Teori

Dalam ilmu komputer, tree adalah sebuah struktur data yang secara bentuk
menyerupai sebuah pohon, yang terdiri dari serangkaian node (simpul) yang saling
berhubungan. Node-node tersebut dihubungkan oleh sebuah vektor. Setiap node
dapat memiliki 0 atau lebih node anak (child). Sebuah node yang memiliki node
anak disebut node induk (parent). Sebuah node anak hanya memiliki satu node
induk. Sesuai konvensi ilmu komputer, tree bertumbuh ke bawah, tidak seperti
pohon di dunia nyata yang tumbuh ke atas. Dengan demikian node anak akan
digambarkan berada di bawah node induknya.
Node yang berada di pangkal tree disebut node root (akar), sedangkan node yang
berada paling ujung pada piramida tree disebut node leaf (daun).

Ilustrasi Tree:


Binary Tree (Pohon Biner)

83
Dalam mata kuliah struktur data, secara khusus akan dipelajari mengenai pohon
biner. Pohon biner adalah sebuah tree yang pada masing-masing simpulnya hanya
dapat memiliki maksimum 2 (dua) simpul anak. Tidak boleh lebih. Pada pohon
biner, umumnya kedua node anak disebut dengan posisinya, yaitu kiri dan kanan.
Beberapa istilah pada pohon biner:
- Size (ukuran): jumlah total node yang terdapat pada pohon biner tersebut.
- Depth (kedalaman): panjang jalur yang menghubungkan sebuah node
sampai ke node anaknya yang paling ujung (leaf). Depth biasa juga
disebut height.
Full Binary Tree (Pohon Biner Penuh) adalah pohon biner yang setiap nodenya
pasti memiliki 0 atau 2 node anak.
Perfect Binary Tree (Pohon Biner Sempurna) adalah pohon biner yang semua node
leafnya berada pada kedalaman yang sama dari node root. Juga disebut sebagai
Complete Binary Tree (Pohon Biner Lengkap)
Almost Complete Binary Tree (Pohon Biner Hampir Lengkap) adalah pohon biner
yang setiap nodenya dapat memiliki 0 node anak, atau memiliki kiri, atau jika
memiliki kanan harus memiliki kiri. Tidak boleh memiliki kanan saja.

3. Tugas Pendahuluan

1. Apa yang dimaksud dengan Tree
2. Jelaskan perbedaan cara kerja antara Binary Tree, AVL Tree, Red Black
Tree dan B-Tree.


4. Praktikum

Percobaan 1. Binary Class Test
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class BinaryClassTest {
private static int cari;
private static int cacahData;

public static void main(String[] args)
{
BinaryTree bt = new BinaryTree(); // Membuat objek bt bertipe
BinaryTree.
System.out.print("Berapa data yang akan dimasukkan ke BinaryTree? ");
cacahData = inputData();

84
for (int i=0; i<cacahData; i++){
System.out.print("Data ke-" + (i+1) + " = ");
bt.insert(inputData());
}
System.out.print("Data yang Anda cari ? ");
cari = inputData();
Node found = (Node) bt.find(cari); // find node with key 25
if(found != null)
System.out.println("Node dengan key " + cari + " ditemukan.");
else
System.out.println("Node key " + cari + " tidak dapat ditemukan.");
}

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;
}
}

Percobaan 2. Binary Tree
class BinaryTree
{
private Node root; // Membentuk akar (root) BinaryTree

public Object find(int key)
{
Node current = root; // Mulai dari akar (root)
while(current.iData != key) // Selama tidak sesuai
{
if(key < current.iData) // Pergi ke cabang kiri?
current = current.leftChild;
else
current = current.rightChild; // Atau pergi ke cabang kanan.
if(current == null) // Jika tidak memiliki anak.

85
return null;
}
return current; // Data yang dicari ditemukan.
}

public void insert(int id)
{
{
Node newNode = new Node(); // Membuat Node yang akan disisipkan.
newNode.iData = id; // Menyisipkan data.
if(root==null) // Jika tidak ada Node di akar (root).
root = newNode;
else
{
Node current = root; // Mulai dari akar (root).
Node parent;
while(true) // hadir secara internal.
{
parent = current;
if(id < current.iData) // Pergi ke kiri.
{
current = current.leftChild;
if(current == null) // Akhir cabang kiri.
{ // Sisipkan di kiri.
parent.leftChild = newNode;
return;
}
} // Akhir perjalanan ke kiri.
else // Atau pergi ke kanan.
{
current = current.rightChild;
if(current == null) // Akhir perjalanan cabang kanan.
{ // Sisipkan di kanan.
parent.rightChild = newNode;
return;
}
} // Akhir perjalanan ke kanan.
} // Akhir while
} // Akhir bukan akar (root).
} // Akhir insert()
}


86
public boolean delete(int id)
{ // (Asumsi pohon tidak kosong)
Node current = root;
Node parent = root;
boolean isLeftChild = true;
while(current.iData != id) // Mencari Node yang akan dihapus.
{
parent = current;
if(id < current.iData) // Pergi ke kiri?
{
isLeftChild = true;
current = current.leftChild;
}
else // Atau pergi ke kanan?
{
isLeftChild = false;
current = current.rightChild;
}
if(current == null) // Akhir baris
return false; // Node yang dicari tidak ditemukan.
} // end while
// Node yang akan dihapus ditemukan.
// Jika Node tidak memiliki anak, hapus!
if(current.leftChild==null &&
current.rightChild==null)
{
if(current == root) // Jika Node yang dihapus merupakan akar (Node).
root = null; // Pohon biner menjadi kosong.
else if(isLeftChild) // Jika Node yang dihapus adalah anak sebelah kiri.
parent.leftChild = null; // Pemutusan koneksi.
else // Jika Node yang akan dihapus adalah anak sebelah kanan.
parent.rightChild = null;
}
// Jika tidak ada anak kanan, ganti dengan subpohon kiri.
else if(current.rightChild==null)
if(current == root)
root = current.leftChild;
else if(isLeftChild) // Anak sebelah kiri induk.
parent.leftChild = current.leftChild;
else // Anak sebelah kanan induk.
parent.rightChild = current.leftChild;
// Jika tak ada anak kiri, gantikan dengan subpohon sebelah kanan.

87
else if(current.leftChild==null)
if(current == root)
root = current.rightChild;
else if(isLeftChild) // Anak sebelah kiri induk.
parent.leftChild = current.rightChild;
else // Anak sebelah kanan induk.
parent.rightChild = current.rightChild;
else // Dua anak, gantikan dengan successor inorder.
{
// Mendapatkan successor Node untuk dihapus (current)
Node successor = getSuccessor(current);
// Menghubungkan induk Node saat ini ke successor.
if(current == root)
root = successor;
else if(isLeftChild)
parent.leftChild = successor;
else
parent.rightChild = successor;
// connect successor to current's left child
successor.leftChild = current.leftChild;
} // end else two children
// (successor tidak mempunyai anak sebwlah kiri)
return true;
} // end delete()

// Mengembalikan Node yang memiliki nilai terbesar berikuntnya setelah delNode,
// pergi ke anak kanan, kemudian turunan kiri anak sebalah kanan.
private Node getSuccessor(Node delNode)
{
Node successorParent = delNode;
Node successor = delNode;
Node current = delNode.rightChild; // Pergi ke anak sebelah kanan.
while(current != null) // Hingga habis.
{ // Anak kiri.
successorParent = successor;
successor = current;
current = current.leftChild; // Pergi ke anak sebelah kiri.
}
// Jika successor bukan anak seblah kanan.
if(successor != delNode.rightChild)
{ // Buat hubungan.
successorParent.leftChild = successor.rightChild;

88
successor.rightChild = delNode.rightChild;
}
return successor;
}
//Mencari simpul (Node) yang memiliki nilai terkecil.
public Node minimum()
{
Node current, last = null;
// Mulai dari akar (root).
current = root;
// Hingga dasar pohon biner.
while(current != null)
{
// Mencatat Node
last = current;
// Pergi ke anak kiri.
current = current.leftChild;
}
return last;
}
} // end class BinaryTree

Percobaan 3. Node
class Node
{
int iData; // data yang digunakan sebagai nilai kunci.
Node leftChild; // Simpul rujukan ke anak sebelah kiri.
Node rightChild; // Simpul rujukan ke anak sebelah kanan.
}

5. Tugas Praktikum

1. Buatlah fungsi untuk menghapus sebuah node tertentu. Inputnya adalah node
yang ingin dihapus.
2. Buatlah fungsi untuk mencari dan menampilkan node anak (kiri + kanan) dari
sebuah node tertentu. Inputnya adalah node yang ingin ditampilkan anaknya.
Untuk pengerjaannya boleh memakai 1 fungsi atau lebih.




89
MODUL 11
HASH TABLE


1. Tujuan

Mengimplementasikan konsep Hash pada Java
Memahami Enumeration, Iterator dan Interface Iterable
Mengimplementasikan penggunaan Iterator untuk Penelusuran Table Hash


2. Dasar Teori

Hash Table adalah struktur data yang sering digunakan untuk
mengimplementasikan ADT Dictionary, yaitu ADT yang hanya
mengizinkan pencarian, penyisipan, dan penghapusan elemen-elemen
yang ada didalamnya



3. Tugas Pendahuluan

1. Apa yang dimaksud dengan :
a. Hash table
b. Enumeration
c. Iterator
d. Interface Iterable
2. Bagaimana cara menggunakan iterator untuk penelusuran table hash


4. Praktikum

Percobaan 1. HashAssociation
package packageHashTable;
class HashAssociation<K extends Number, V> {
protected K theKey;
protected V theValue;
protected K key;
protected V value;

90

HashAssociation() {
this.theKey = key;
this.theValue = value;
}

V setValue(V value) {
V oldValue = theValue;
theValue = value;
return oldValue;
}

K getTheKey() {
return theKey;
}

void setTheKey(K theKey) {
this.theKey = theKey;
}

V getTheValue() {
return theValue;
}

void setTheValue(V theValue) {
this.theValue = theValue;
}
}

Percobaan 2. HashTable
package packageHashTable;
import java.util.Vector;


public class HashTable<K, V> {

int count;
int hash;
final double maximumLoadFactor = 0.5;
public static HashAssociation<Integer, String> DATA;
public static Vector<HashAssociation<Integer, String>> data;


91
public HashTable(int initialCapacity) {
if (initialCapacity > 0) {
System.out.print("Kapasitas Hashtable positip.");
data = new Vector<HashAssociation<Integer,
String>>();
data.setSize(initialCapacity);
count = 0;
}
}

public HashTable() {
this(100);
}

protected int locate(K key) {
hash = Math.abs(key.hashCode() % data.size());
while (data.get(hash) != null) {
if (data.get(hash) != null) {
if (key.equals(data.get(hash).getTheKey()))
return hash;
}
hash = (1 + hash) % data.size();
}
return hash;
}

public String put(K key, V value) {
if (maximumLoadFactor * data.size() <= (1 + count)) {
System.out.println("Hash Table is FULL");
}
int hash = locate(key);
if (data.get(hash) == null) {
DATA = new HashAssociation<Integer, String>();
data.set(hash, DATA);
count++;
return null;
} else {
HashAssociation<Integer, String> a = data.get(hash);
String theValue = a.getTheValue();
String oldValue = theValue;
a.setValue((String) theValue);
return oldValue;

92
}
}

public int containsValueByKey(K key) {
int hash = locate(key);
if (data.get(hash) != null)
return -99;
else
return hash;
}

public Vector<HashAssociation<Integer, String>> getData() {
return data;
}

public void setDATA(K key, V value) {
put(key, value);
}

public boolean containsValue(K key) {
int hash = locate(key);
return data.get(hash) != null;
}

public String get(K key) {
int hash = locate(key);
if (data.get(hash) == null)
return null;
return data.get(hash).getTheValue();
}
}

Percobaan 3. TesthashTable
package packageHashTable;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class TestHashTable {
HashTable<Integer, String> ht;
public static void main(String[] args) {

93
HashTable<Integer, String> ht = new HashTable<Integer,
String>();
System.out.print("\nBerapa data yang akan dimasukkan? ");
int jData = inputData();
for (int i = 0; i < jData; i++) {
System.out.print("Masukkan kunci ke-" + (i + 1) + " :
");
int key = inputData();
System.out.print("Masukkan nilai ke-" + (i + 1) + " : ");
String value = inputNilai();
ht.setDATA(key, value);
}
System.out.println("Data-data sudah masuk. Mau memeriksa ?
");
System.out.print("Masukkan kunci yang dicari : ");
int kunci = inputData();
int kunciPencarian = ht.containsValueByKey(kunci);
if (kunciPencarian == -99) {
System.out.print("Data Anda cari tidak ada bok!!");
} else {
System.out.println("Data dengan kunci : " + kunci + "
ada!");
}
}

private static String inputNilai() {
String data = null;
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in));
String stringInput = null;
try {
stringInput = bfr.readLine();
} catch (IOException e) {
e.printStackTrace();
}
data = String.valueOf(stringInput);
return data;
}

private static int inputData() {
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in));

94
String angkaInput = null;
try {
angkaInput = bfr.readLine();
} catch (IOException e) {
e.printStackTrace();
}
int Data = Integer.valueOf(angkaInput).intValue();
return Data;
}
}

Percobaan 4. AbstractIterator
package packageTestVectorIterator;

import java.util.Enumeration;
import java.util.Iterator;

public abstract class AbstractIterator<E>
implements Enumeration<E>, Iterator<E>, Iterable<E>
{
public abstract void reset();

public abstract boolean hasNext();

public abstract E get();

public abstract E next();

public void remove()
{
System.out.print("remove() belum diimplementasikan.");
}
final public boolean hasMoreElements()
{
return hasNext();
}
final public E nextElement()
{
return next();
}
public Iterator<E> iterator(VectorIterator<HashAssociation<Integer, String>> vi)
{

95
return this;
}
}

Percobaan 5. HashAssociation
package packageTestVectorIterator;
class HashAssociation<K extends Number, V> {
protected K theKey;
protected V theValue;
protected K key;
protected V value;

HashAssociation() {
this.theKey = key;
this.theValue = value;
}

V setValue(V value) {
V oldValue = theValue;
theValue = value;
return oldValue;
}

K getTheKey() {
return theKey;
}

void setTheKey(K theKey) {
this.theKey = theKey;
}

V getTheValue() {
return theValue;
}

void setTheValue(V theValue) {
this.theValue = theValue;
}
}

Percobaan 6. VectorIterator
package packageTestVectorIterator;

96
import java.util.Iterator;
import java.util.Vector;


@SuppressWarnings("hiding")
class VectorIterator<E> extends AbstractIterator<E> {
protected Vector<E> theVector;
protected int current;
public Iterator<E> iterator()
{
return new VectorIterator<E>();
}
public void reset()
{
current = 0;
}
public boolean hasNext()
{
return current < theVector.size();
}
public E get()
{
return theVector.get(current);
}
public E next()
{
return theVector.get(current++);
}
}

Percobaan 7. TestIteratorforVector
package packageTestVectorIterator;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.Vector;

public class TestIteratorforVector {
static Vector <String> vector = new Vector<String>();
static Iterator<String> i;
public static void main(String[] args) {

97
System.out.print("Berapa data yang akan dimasukkan? ");
int jData = inputData();
for (int i = 0; i < jData; i++) {
System.out.print("Masukkan nama ke-" + (i + 1) + " : ");
String value = inputNilai();
vector.add(value);
}
System.out.print("Data-data sudah masuk. Mau memeriksa (1) ? ");
int periksa = inputData();
if (periksa == 1) tampilData();
}

private static void tampilData() {
int j=1;
i = (Iterator<String>) vector.iterator();
while(i.hasNext())
{
System.out.print("\nData ke-" + j + " adalah " +
i.next().toString());
j++;
}
System.out.println();

}

private static String inputNilai() {
String data = null;
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in));
String stringInput = null;
try {
stringInput = bfr.readLine();
} catch (IOException e) {
e.printStackTrace();
}
data = String.valueOf(stringInput);
return data;
}

private static int inputData() {
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in));

98
String angkaInput = null;
try {
angkaInput = bfr.readLine();
} catch (IOException e) {
e.printStackTrace();
}
int Data = Integer.valueOf(angkaInput).intValue();
return Data;
}
}

Percobaan 8. TestVectorIterator_forHash
package packageTestVectorIterator;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Vector;

public class TestVectorIterator_forHAssc extends
VectorIterator<HashAssociation<Integer, String>> {

static Vector<HashAssociation<Integer, String>> vector =
new Vector<HashAssociation<Integer, String>>();

public TestVectorIterator_forHAssc
(Vector<HashAssociation<Integer, String>> v) {
super();
}

public static void main(String[] args) {
System.out.print("\nBerapa data yang akan dimasukkan? ");
int jData = inputData();
for (int i = 0; i < jData; i++) {
HashAssociation<Integer, String> ha =
new HashAssociation<Integer, String>();;
System.out.print("Masukkan kunci ke-" + (i + 1) + " :
");
int key = inputData();
System.out.print("Masukkan nilai ke-" + (i + 1) + " : ");
String value = inputNilai();
ha.setTheKey(key);
ha.setTheValue(value);

99
vector.add(ha);
}
System.out.print("\nData-data sudah masuk. Mau memeriksa
(1)? ");
int periksa = inputData();
if (periksa == 1)
tampilData();
}

private static void tampilData() {
int j = 1;
for (HashAssociation<Integer, String> ha : vector){
System.out.println("Data ke-" + j + " KEY : "
+ ha.getTheKey().toString() + "
VALUE : "
+ ha.getTheValue().toString());
j++;
}
}

private static String inputNilai() {
String data = null;
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in));
String stringInput = null;
try {
stringInput = bfr.readLine();
} catch (IOException e) {
e.printStackTrace();
}
data = String.valueOf(stringInput);
return 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();

100
}
int Data = Integer.valueOf(angkaInput).intValue();
return Data;
}
}

5. Tugas Praktikum

Buat Kesimpulan dengan deskripsi tentang penggunaan struktur data hash table
dari beberapa percobaan diatas

































101
MODUL 12
GRAPH


1.Tujuan

Mendeklarasikan dan membuat graph
Mengakses elemen-elemen di dalam graph
Menentukan jumlah elemen dalam sebuah graph


2. Dasar Teori

Graph merupakan salah satu dari beberapa struktur data yang paling
sering diaplikasikan dalam pemrograman komputer. Jika memutuskan
untuk menggunakan penyimpanan data yang bersifat eksternal (external
storage), tidak membutuhkan graph, tetapi untuk permasalahan dimana
diperlukan representasi internal dalam memori komputer untuk suatu
struktur data, graph harus digunakan. Graph terdiri dari graph tidak
berbobot (unweighted graph) dan graph berbobot (weighted graph)


3. Tugas Pendahuluan

1. Jelaskan pengertian algoritma-algoritma berikut ini:
a. Algoritma DFS (Depth First Search)
b. Algoritma BFS (Breath First Search)
c. Algoritma MST (Minimum Spanning Tree)
d. Algoritma pengurutan topologi pada graph berarah (directed graph)

4. Praktikum

Percobaan 1. Graph
package DFS_BFS_MFS;

class Graph
{
private final int MAX_VERTS = 20;
private Vertex vertexList[]; // Daftar simpul.

102
private int adjMat[][]; // adjacency matrix
private int nVerts; // jumlah simpul saat ini.
private static StackX theStack;
private static QueueX theQueue;
// ------------------
public Graph() // constructor
{
vertexList = new Vertex[MAX_VERTS];
// adjacency matrix
adjMat = new int[MAX_VERTS][MAX_VERTS];
nVerts = 0;
for(int j=0; j<MAX_VERTS; j++) // Menginisialisasi adjacency
for(int k=0; k<MAX_VERTS; k++) // matrix ke nilai 0.
adjMat[j][k] = 0;
theStack = new StackX();
theQueue = new QueueX();
} // end constructor
// ------------------
public void addVertex(char lab)
{
vertexList[nVerts++] = new Vertex(lab);
}

// ------------------
public void addEdge(int start, int end)
{
adjMat[start][end] = 1;
adjMat[end][start] = 1;
}

// ------------------
public void displayVertex(int v)
{
System.out.print(vertexList[v].label);
}
// ------------------

public void dfs() // depth-first search
{ //Mulai dari vertex 0
vertexList[0].wasVisited = true; // Tandai.
displayVertex(0); // Tampilkan.
theStack.push(0); // Masukkan (push) ke Stack.

103
while( !theStack.isEmpty() ) // Hingga stack kosong,
{
// Mendapatkan simpul yang
// belum dikunjungi dan berdampingan dengan
// simpul yang ada di bagian atas Stack.
int v = getAdjUnvisitedVertex( theStack.peek() );
if(v == -1) // Jika vertex tidak ada,
theStack.pop();
else // Jika vertex ada,
{
vertexList[v].wasVisited = true; // Tandai.
displayVertex(v); // Tampilkan.
theStack.push(v); // Masukkan (push) ke Stack.
}
} // end while
// Stack kosong.
for(int j=0; j<nVerts; j++) // Pengaturan-ulang penanda.
vertexList[j].wasVisited = false;
} // end dfs
// ------------------


//------------------------------------------------------------
public void bfs() // breadth-first search
{ // Mulai vertex 0
vertexList[0].wasVisited = true; // Tandai
displayVertex(0); // Tampilkan.
theQueue.insert(0); // Tambah di bagian belakang.
int v2;
while( !theQueue.isEmpty() ) // Hingga queue kosong,
{
int v1 = theQueue.remove(); // Hapus vertex di bagian depan.
// Hingga tidak ada simpul tetangga yang belum dikunjungi.
while( (v2=getAdjUnvisitedVertex(v1)) != -1 )
{ // get one,
vertexList[v2].wasVisited = true; // Tandai.
displayVertex(v2); // Tampilkan.
theQueue.insert(v2); // Sisipkan.
} // end while
} // end while(queue tidak kosong)
//Stack kosong
for(int j=0; j<nVerts; j++) // Pengaturan-ulang flags

104
vertexList[j].wasVisited = false;
} // end bfs()
// ------------------------------------------------------------

// Mendapatkan simpul yang
// belum dikunjungi dan berdampingan dengan
// simpul yang ada di bagian atas Stack.
public int getAdjUnvisitedVertex(int v)
{
for(int j=0; j<nVerts; j++)
if(adjMat[v][j]==1 && vertexList[j].wasVisited==false)
return j;
return -1;
} // end getAdjUnvisitedVert()

// ------------------
public void mps() {
vertexList[0].wasVisited = true; // Tandai.
theStack.push(0); // Masukkan (push) ke Stack.
while(!theStack.isEmpty() ) // Hingga stack kosong.
{ // Mendapatkan nilai pada bagian atas (top) stack.
int currentVertex = theStack.peek();
// Hingga tidak ada simpul tetangga yang belum dikunjungi.
int v = getAdjUnvisitedVertex(currentVertex);
if(v == -1) // Jika tidak ada simpul tetangga lagi.
theStack.pop(); // Lakukan pop.
else // Simpul tetangga ada.
{
vertexList[v].wasVisited = true; // Tandai.
theStack.push(v); // Masukkan (push) ke stack.
// Tampilkan lintasan.
displayVertex(currentVertex); // dari currentV
displayVertex(v); // ke v
System.out.print(" ");
}
} // end while(stack tidak kosong)
// Stack kosong
for(int j=0; j<nVerts; j++) // Pengaturan-ulang flags
vertexList[j].wasVisited = false;
} // end mst()
} // end class Graph


105

Percobaan 2. QueueX
package DFS_BFS_MFS;
class QueueX
{
private final int SIZE = 20;
private int[] queArray;
private int front;
private int rear;
public QueueX() // constructor
{
queArray = new int[SIZE];
front = 0;
rear = -1;
}
public void insert(int j) //Memasukkan item ke bagian belakang queue.
{
if(rear == SIZE-1)
rear = -1;
queArray[++rear] = j;
}
public int remove() // Mengambil item dari bagian depan queue.
{
int temp = queArray[front++];
if(front == SIZE)
front = 0;
return temp;
}
public boolean isEmpty() // Bernilai true queue kosong.
{
return ( rear+1==front || (front+SIZE-1==rear) );
}
} // end class Queue

Percobaan 3. StackX
package DFS_BFS_MFS;

// ---------------------------------------------------------
class StackX
{
private final int SIZE = 20;
private int[] st;

106
private int top;
public StackX() // Constructor.
{
st = new int[SIZE]; //Membuat array.
top = -1;
}
public void push(int j) // Menaruh item ke stack.
{ st[++top] = j; }
public int pop() // Mengambil item dari stack.
{ return st[top--]; }
public int peek() // Melihat simpul di atas (top) stack.
{ return st[top]; }
public boolean isEmpty() // Bernilai true jika stack kosong.
{ return (top == -1); }
} // end class StackX

Percobaan 4. TestGraph
package DFS_BFS_MFS;


public class TestGraphDFSandBFSandMFS {
public static void main(String[] args)
{
Graph theGraph = new Graph();

theGraph.addVertex('A'); // 0
theGraph.addVertex('B'); // 1
theGraph.addVertex('C'); // 2
theGraph.addVertex('D'); // 3
theGraph.addVertex('E'); // 4
theGraph.addEdge(0, 1); // AB
theGraph.addEdge(0, 2); // AC
theGraph.addEdge(0, 3); // AD
theGraph.addEdge(0, 4); // AE
theGraph.addEdge(1, 2); // BC
theGraph.addEdge(1, 3); // BD
theGraph.addEdge(1, 4); // BE
theGraph.addEdge(2, 3); // CD
theGraph.addEdge(2, 4); // CE
theGraph.addEdge(3, 4); // DE

System.out.println("\nKUNJUNGAN GRAPH :");

107
System.out.print("\nKunjungan Dengan DFS (Deep First Searching) :
");
theGraph.dfs(); // depth-first search
System.out.print("\nKunjungan Dengan BFS (Breadth First Searching) :
");
theGraph.bfs(); // depth-first search
System.out.print("\nKunjungan Dengan MFS (Minimum Spanning Tree)
: ");
theGraph.mps(); // Minimum Spanning Tree
} // end main()
}

Percobaan 5. Vertex

package DFS_BFS_MFS;
class Vertex
{
public char label; // Label (misal. 'A')
public boolean wasVisited;
// ------------------
public Vertex(char lab) // Constructor.
{
label = lab;
wasVisited = false;
}
// ------------------
} // end class Vertex

Percobaan 6. MFS

package MFS_for_WEIGHTGRAPH;

public class Edge {
public int srcVert; // index vertex awal.
public int destVert; // index vertex akhir.
public int distance; // jarak dari src ke dest
public Edge(int sv, int dv, int d) // constructor
{
srcVert = sv;
destVert = dv;
distance = d;
}

108
} // end class Edge

Percobaan 7. graph MFS
package MFS_for_WEIGHTGRAPH;

class Graph
{
private final int MAX_VERTS = 20;
private final int INFINITY = 1000000;
private Vertex vertexList[]; // daftar vertx
private int adjMat[][]; // adjacency matrix
private int nVerts; // jumlah vertex saat ini.
private int currentVert;
private PriorityQ thePQ;
private int nTree; // jumlah vertex di tree


// ------------------------------------------------------------
public Graph() // constructor
{
vertexList = new Vertex[MAX_VERTS];
// adjacency matrix
adjMat = new int[MAX_VERTS][MAX_VERTS];
nVerts = 0;
for(int j=0; j<MAX_VERTS; j++) // Menginisialisasi adjacency
for(int k=0; k<MAX_VERTS; k++) // matrix ke nilai 0
adjMat[j][k] = INFINITY;
thePQ = new PriorityQ();
} // end constructor
// ------------------------------------------------------------
public void addVertex(char lab)
{
vertexList[nVerts++] = new Vertex(lab);
}
// ------------------------------------------------------------
public void addEdge(int start, int end, int weight)
{
adjMat[start][end] = weight;
adjMat[end][start] = weight;
}
// ------------------------------------------------------------
public void displayVertex(int v)

109
{
System.out.print(vertexList[v].label);
}
// ------------------------------------------------------------
public void mstw() // Algoritma Minimum Spanning Tree
{
currentVert = 0; // start di 0
while(nTree < nVerts-1) // selama tidak ada verts di tree
{ // Letakkan currentVert di tree
vertexList[currentVert].isInTree = true;
nTree++;
// Sisipkan lintasan (edge) yang berdampingan
// dengan currentVert ke dalam PQ
for(int j=0; j<nVerts; j++) // Untuk setiap vertex,
{
if(j==currentVert) // Lompati jika sudah dilewati.
continue;
if(vertexList[j].isInTree) // Lompati jika ada di tree
continue;
int distance = adjMat[currentVert][j];
if( distance == INFINITY) // Lompati jika tidak ada lintasan (edge)
continue;
putInPQ(j, distance); // Letakkan di PQ (mungkin)
}
if(thePQ.size()==0) // Tidak ada vertex di PQ?
{
System.out.println(" GRAPH TIDAK TERHUBUNG!");
return;
}
// Hapus lintasan (edge) dengan jarak minimum, dari PQ
Edge theEdge = thePQ.removeMin();
int sourceVert = theEdge.srcVert;
currentVert = theEdge.destVert;
// Menampilkan lintasan (edge) dari source ke current
System.out.print( vertexList[sourceVert].label );
System.out.print( vertexList[currentVert].label );
System.out.print(" ");
} // end while(tidak semua verts di tree)
// mst is complete
for(int j=0; j<nVerts; j++) // Hilangkan tanda di vertex-vertex.
vertexList[j].isInTree = false;
} // end mstw

110

// ------------------------------------------------------------
public void putInPQ(int newVert, int newDist)
{
// Apa ada lintasan (edge) lain yang bertujuan sama?
int queueIndex = thePQ.find(newVert);
if(queueIndex != -1) // Mendapatkan index lintasan (edge).
{
Edge tempEdge = thePQ.peekN(queueIndex); // Mendapatkan lintasan (edge).
int oldDist = tempEdge.distance;
if(oldDist > newDist) // Jika lintasan (edge) baru lebih pendek.
{
thePQ.removeN(queueIndex); // Hapus lintasan (edge) lama.
Edge theEdge = new Edge(currentVert, newVert, newDist);
thePQ.insert(theEdge); // Sisipkan lintasan (edge) baru.
}
// else tidak ada aksi apa-apa;
// tinggalkan vertex lama di sini.
} // end if
else // Tidak ada lintasan (edge) dengan vertex tujuan yang sama
{ // sisipkan yang baru.
Edge theEdge = new Edge(currentVert, newVert, newDist);
thePQ.insert(theEdge);
}
} // end putInPQ()
// ------------------------------------------------------------
} // end class Graph

Percobaan 8. MSTWApp

package MFS_for_WEIGHTGRAPH;

class MSTWApp
{
public static void main(String[] args)
{
Graph theGraph = new Graph();
theGraph.addVertex('A'); // 0 (start for mst)
theGraph.addVertex('B'); // 1
theGraph.addVertex('C'); // 2
theGraph.addVertex('D'); // 3
theGraph.addVertex('E'); // 4

111
theGraph.addVertex('F'); // 5
theGraph.addEdge(0, 1, 6); // AB 6
theGraph.addEdge(0, 3, 4); // AD 4
theGraph.addEdge(1, 2, 10); // BC 10
theGraph.addEdge(1, 3, 7); // BD 7
theGraph.addEdge(1, 4, 7); // BE 7
theGraph.addEdge(2, 3, 8); // CD 8
theGraph.addEdge(2, 4, 5); // CE 5
theGraph.addEdge(2, 5, 6); // CF 6
theGraph.addEdge(3, 4, 12); // DE 12
theGraph.addEdge(4, 5, 7); // EF 7
System.out.println("Minimum Spanning Tree : ");
theGraph.mstw(); // minimum spanning tree
} // end main()
} // end class MSTWApp
///////////////////////////////////////////////////////////////

Percobaan 9. PriorityQ

package MFS_for_WEIGHTGRAPH;

class PriorityQ
{
// array dalam keadaan terurut, dari max = 0 hingga min = size-1
private final int SIZE = 20;
private Edge[] queArray;
private int size;
public PriorityQ() // constructor
{
queArray = new Edge[SIZE];
size = 0;
}
public void insert(Edge item) // Masukkan item dalam keadaan terurut.
{
int j;
for(j=0; j<size; j++) // Temukan tempat penyisipan.
if( item.distance >= queArray[j].distance )
break;
for(int k=size-1; k>=j; k--) // Gerakkan item ke atas.
queArray[k+1] = queArray[k];
queArray[j] = item; // Sisipkan item.
size++;

112
}
public Edge removeMin() // Hapus item minimum.
{ return queArray[--size]; }
public void removeN(int n) // Hapus item di n
{
for(int j=n; j<size-1; j++) // Gerakkan item ke bawah.
queArray[j] = queArray[j+1];
size--;
}
public Edge peekMin() // Lihat item minimum.
{ return queArray[size-1]; }
public int size() // Kembalikan jumlah item.
{ return size; }
public boolean isEmpty() // true jika queue kosong.
{ return (size==0); }
public Edge peekN(int n) // Lihat item n
{ return queArray[n]; }
public int find(int findDex) // Temukan item dengan nilai destVert yang
dispesifikasi.
{
for(int j=0; j<size; j++)
if(queArray[j].destVert == findDex)
return j;
return -1;
}
} // end class PriorityQ

Percobaan 10. MST Vertex

package MFS_for_WEIGHTGRAPH;

class Vertex
{
public char label; // label (misal : 'A')
public boolean isInTree;
// ------------------------------------------------------------
public Vertex(char lab) // constructor
{
label = lab;
isInTree = false;
}
// ------------------------------------------------------------

113
} // end class Vertex

Percobaan 11. Distpar

package SHORTESTPATH_WEIGHTGRAPH;

class DistPar // jarak (distance) dan induk (parent).
{ // item-item tersimpan di array sPath.
public int distance; // jarak dari start ke vertex ini.
public int parentVert; // induk (parent) vertex saat ini.
public DistPar(int pv, int d) // constructor
{
distance = d;
parentVert = pv;
}
} // end class DistPar

Percobaan 12. Graph shortestPath

package SHORTESTPATH_WEIGHTGRAPH;

class Graph
{
private final int MAX_VERTS = 20;
private final int INFINITY = 1000000;
private Vertex vertexList[]; // Daftar vertex-vertex.
private int adjMat[][]; // adjacency matrix
private int nVerts; // jumlah vertex saat ini.
private int nTree; // jumlah verts di tree.
// array untuk data lintasan terpendek
// (shortest-path)
private DistPar sPath[];
private int currentVert; // vertex saat ini.
private int startToCurrent; // jarak ke currentVert.


// ------------------------------------------------------------
public Graph() // constructor
{
vertexList = new Vertex[MAX_VERTS];
// adjacency matrix
adjMat = new int[MAX_VERTS][MAX_VERTS];

114
nVerts = 0;
nTree = 0;
// menginisialisasi adjacency matrix
// ke infinity.
for(int j=0; j<MAX_VERTS; j++)
for(int k=0; k<MAX_VERTS; k++)
// Lintasan terpendek (shortest path).
adjMat[j][k] = INFINITY; sPath = new DistPar[MAX_VERTS];
} // end constructor


// ------------------------------------------------------------
public void addVertex(char lab)
{
vertexList[nVerts++] = new Vertex(lab);
}


// ------------------------------------------------------------
public void addEdge(int start, int end, int weight)
{
adjMat[start][end] = weight; // (berarah)
}


// ------------------------------------------------------------
// Menemukan semua lintasan terpendek
// (shortest path).
public void path()
{
int startTree = 0; // mulai dari vertex 0
vertexList[startTree].isInTree = true;
nTree = 1; // letakkan di tree
// transfer baris-baris (distances) dari
// adjMat ke sPath.
for(int j=0; j<nVerts; j++)
{
int tempDist = adjMat[startTree][j];
sPath[j] = new DistPar(startTree, tempDist);
}
// hingga semua vertex ada di tree.
while(nTree < nVerts)

115
{
// mendapat nilai minimum dari sPath.
int indexMin = getMin();
int minDist = sPath[indexMin].distance;
if(minDist == INFINITY) // jika semua infinite
{ // atau ada di tree,
System.out.println
("Simpul (vertex) tidak dapat dicapai! ");
break; // sPath selesai.
}
else
{ // melakukan pengaturan-ulang currentVert.
currentVert = indexMin; // ke vert terdekat.
startToCurrent = sPath[indexMin].distance;
// jarak minimum dari startTree adalah
// ke currentVert, dan startToCurrent.
}
// Letakkan vertex saat ini ke tree.
vertexList[currentVert].isInTree = true;
nTree++;
adjust_sPath(); // perbaharui array sPath[].
} // end while(nTree<nVerts)
displayPaths(); // tampilkan isi sPath[]
nTree = 0; // hapus tree.
for(int j=0; j<nVerts; j++)
vertexList[j].isInTree = false;
} // end path()


// ------------------------------------------------------------
public int getMin() // mendapatkan entry dari sPath
{ // yang memiliki jarak minimum.
int minDist = INFINITY; // asumsikan minimum.
int indexMin = 0;
for(int j=1; j<nVerts; j++) // untuk setiap vertex,
{ // jika ada di tree dan
if( !vertexList[j].isInTree && // lebih kecil dari yang lama.
sPath[j].distance < minDist )
{
minDist = sPath[j].distance;
indexMin = j; // update minimum
}

116
} // end for
return indexMin; // mengembalikan index minimum
} // end getMin()


// ------------------------------------------------------------
public void adjust_sPath()
{
// mengatur nilai-nilai dalam array sPath
// yang berisi lintasan terpendek.
int column = 1; // lompati vertex awal.
while(column < nVerts) // melintas kolom.
{
// jika kolom vertex ada di tree, lompati.
if( vertexList[column].isInTree )
{
column++;
continue;
}
// hitung jarak dari suatu entry sPath,
// dapatkan lintasan (edge) dari currentVert ke kolom.
int currentToFringe = adjMat[currentVert][column];
// tambahkan jarak dari start
int startToFringe = startToCurrent + currentToFringe;
// dapatkan jarak (distance) entri sPath saat ini.
int sPathDist = sPath[column].distance;
// bandingkan jarak (distance) dari
// start dengan entri sPath.
if(startToFringe < sPathDist) // jika lebih pendek,
{ // perbaharui sPath
sPath[column].parentVert = currentVert;
sPath[column].distance = startToFringe;
}
column++;
} // end while(column < nVerts)
} // end adjust_sPath()


// ------------------------------------------------------------
public void displayPaths()
{
// Menampilkan isi array sPath.

117
for(int j=0; j<nVerts; j++)
{
System.out.print(vertexList[j].label + "="); // B=
if(sPath[j].distance == INFINITY)
System.out.print("inf"); // inf
else
System.out.print(sPath[j].distance); // 50
char parent = vertexList[ sPath[j].parentVert ].label;
System.out.print("(" + parent + ") "); // (A)
}
System.out.println("");
}
// ------------------------------------------------------------
} // end class Graph

Percobaan 13. PathApp

package SHORTESTPATH_WEIGHTGRAPH;

class PathApp
{
public static void main(String[] args)
{
Graph theGraph = new Graph();

theGraph.addVertex('A'); // 0 (start)
theGraph.addVertex('C'); // 2
theGraph.addVertex('B'); // 1
theGraph.addVertex('D'); // 3
theGraph.addVertex('E'); // 4

theGraph.addEdge(0, 1, 50); // AB 50
theGraph.addEdge(0, 3, 80); // AD 80
theGraph.addEdge(1, 2, 60); // BC 60
theGraph.addEdge(1, 3, 90); // BD 90
theGraph.addEdge(2, 4, 40); // CE 40
theGraph.addEdge(3, 2, 20); // DC 20
theGraph.addEdge(3, 4, 70); // DE 70
theGraph.addEdge(4, 1, 50); // EB 50

System.out.println("Shortest paths");
theGraph.path(); // shortest paths

118
System.out.println();
} // end main()
} // end class PathApp

Percobaan 14.Vertex shortestPath

package SHORTESTPATH_WEIGHTGRAPH;

class Vertex
{
public char label; // label (misalnya : 'A')
public boolean isInTree;
// ------------------------------------------------------------
public Vertex(char lab) // constructor
{
label = lab;
isInTree = false;
}
// ------------------------------------------------------------
} // end class Vertex

Percobaan 15. GraphTopo

package topologiSorting;


class GraphTopo
{
private final int MAX_VERTS = 20;
private Vertex vertexList[]; // Daftar vertex
private int adjMat[][]; // adjacency matrix
private int nVerts; // Jumlah vertex
private char sortedArray[];
// ------------------------------------------------------------

public GraphTopo() // constructor
{
vertexList = new Vertex[MAX_VERTS];
// adjacency matrix
adjMat = new int[MAX_VERTS][MAX_VERTS];
nVerts = 0;
for(int j=0; j<MAX_VERTS; j++) // Menginisialisasi adjacency

119
for(int k=0; k<MAX_VERTS; k++) // matrix ke 0
adjMat[j][k] = 0;
sortedArray = new char[MAX_VERTS]; // Label vert terurut.
} // end constructor

// ------------------------------------------------------------
public void addVertex(char lab)
{
vertexList[nVerts++] = new Vertex(lab);
}
// ------------------------------------------------------------
public void addEdge(int start, int end)
{
adjMat[start][end] = 1;
}
// ------------------------------------------------------------
public void displayVertex(int v)
{
System.out.print(vertexList[v].label);
}

// ------------------------------------------------------------
public void topo() // topological sort
{
int orig_nVerts = nVerts; // Mengingat berapa verts
while(nVerts > 0) // sementara vertex ada,
{
// Mendapat vertex tanpa successors, atau -1
int currentVertex = noSuccessors();
if(currentVertex == -1) // harus merupakan siklus
{
System.out.println("ERROR: Graph has cycles");
return;
}
// Menyisipkan label vertex label dalam array terurut (start
hingga end)
sortedArray[nVerts-1] =
vertexList[currentVertex].label;
deleteVertex(currentVertex); // delete vertex
} // end while
// vertices all gone; display sortedArray
System.out.print("Topologically sorted order: \n");

120
for(int j=0; j<orig_nVerts; j++)
System.out.println( sortedArray[j] );
System.out.println("\n");
} // end topo

// ------------------
public int noSuccessors() // Mengembalikan vert tanpa successors
{ // (atau -1 jika verts tidak ada)
boolean isEdge; // Lintasan (edge) dari ke to column dalam adjMat
for(int row=0; row<nVerts; row++) // untuk setiap vertex,
{
isEdge = false; // periksa lintasan (edge)
for(int col=0; col<nVerts; col++)
{
if( adjMat[row][col] > 0 ) // Jika lintasan (edge) ke
{ // yang lain,
isEdge = true;
break; // vertex ini
} // memiliki successor,
} // coba yang lain.
if( !isEdge ) // Jika tidak ada lintasan (edge)
return row; // Tidak ada successor
}
return -1; // Tidak ada vertex
} // end noSuccessors()

// ------------------
public void deleteVertex(int delVert)
{
if(delVert != nVerts-1) // Jika bukan vertex terakhir,
{ // hapus dari vertexList
for(int j=delVert; j<nVerts-1; j++)
vertexList[j] = vertexList[j+1];
// hapus row dari adjMat
for(int row=delVert; row<nVerts-1; row++)
moveRowUp(row, nVerts);
// hapus col dari adjMat
for(int col=delVert; col<nVerts-1; col++)
moveColLeft(col, nVerts-1);
}
nVerts--; // Kurangi vertex
} // end deleteVertex

121
// ------------------
private void moveRowUp(int row, int length)
{
for(int col=0; col<length; col++)
adjMat[row][col] = adjMat[row+1][col];
}
// ------------------
private void moveColLeft(int col, int length)
{
for(int row=0; row<length; row++)
adjMat[row][col] = adjMat[row][col+1];
}
// ------------------------------------------------------------
} // end class Graph

Percobaan 16. TestGraphTopo

package topologiSorting;

public class TestGraphTopo {
public static void main(String[] args)
{
GraphTopo theGraph = new GraphTopo();
theGraph.addVertex('A'); // 0
theGraph.addVertex('B'); // 1
theGraph.addVertex('C'); // 2
theGraph.addVertex('D'); // 3
theGraph.addVertex('E'); // 4
theGraph.addVertex('F'); // 5
theGraph.addVertex('G'); // 6
theGraph.addVertex('H'); // 7
theGraph.addEdge(0, 3); // AD
theGraph.addEdge(0, 4); // AE
theGraph.addEdge(1, 4); // BE
theGraph.addEdge(2, 5); // CF
theGraph.addEdge(3, 6); // DG
theGraph.addEdge(4, 6); // EG
theGraph.addEdge(5, 7); // FH
theGraph.addEdge(6, 7); // GH
theGraph.topo(); // Lakukan pengurutan.
} // end main()
} // end class TopoApp

122

Percobaan 17. VertexTopo

package topologiSorting;
class Vertex
{
public char label; // Label (misal. 'A')
public boolean wasVisited;
// ------------------
public Vertex(char lab) // Constructor.
{
label = lab;
wasVisited = false;
}
// ------------------
} // end class Vertex


5. Tugas Praktikum

Buat Kesimpulan dengan deskripsi tentang penggunaan struktur data graph dari
beberapa percobaan diatas