MODUL PRAKTIKUM STRUKTUR DATA BARU · PDF fileModul Struktur data ini disusun menyesuaikan...

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.


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.


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


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


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).


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 diarahka n ke NULL kepala->data=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; }


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.


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


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)


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

MODUL PRAKTIKUM STRUKTUR DATA BARU · PDF fileModul Struktur data ini disusun menyesuaikan...

Documents

Transcript of MODUL PRAKTIKUM STRUKTUR DATA BARU · PDF fileModul Struktur data ini disusun menyesuaikan...