MODUL-PRAKTIKUM-STRUKTUR-DATA pdf

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

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

MODUL 1 MEMULAI PEMROGRAMAN JAVA 1.. Tujuan •. 2.. Dasar Teori • • •. 3.. 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.. Tugas Pendahuluan 1. 2.. 4.. Membuat program java menggunakan text editor dan console. Jelaskan fitur-fitur teknologi Java seperti, Java Virtual Machine(JVM), garbage collection, dan code security. Jelaskan perbedaan fase-fase pada program Java.. 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 3.

MODUL 2 DASAR-DASAR PEMROGRAMAN JAVA. 1.. Tujuan a. b. c.. 2.. Dasar Teori • •. 3.. 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.. Tugas Pendahuluan 1. 2.. 4.. Memahami konsep ADT (Abstract Data Type) Memahami Class dan Object Memahami Kata-kata kunci (keyword) dan operator-operator pada Java. Apa yang dimaksud dengan kelas dan object. Berikan contoh Apa yang dimaksud dengan Java literal, tipe data primitif, tipe variabel, identifier dan operator. Berikan contoh. 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;. 4.

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

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; 6.

} 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 { 7.

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; 8.

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!"); } } 9.

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 Number Letter Result Str. 2.. Data tipe integer character boolean String. Initial value 10 a true hello. Berikut ini merupakan tampilan yang diharapkan sebagai hasil eksekusi program : number = 10 letter = a result = true str = hello 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++ 10.

MODUL 3 SELEKSI 1.. Tujuan • Mampu membuat program menerima input dari keyboard • Memahami pernyataan IF • Memahami pernyataan Nested IF (IF bersarang) • Memahami switch...case. 2.. Dasar Teori • Terdapat dua cara untuk mendapatkan input: menggunakan class BufferedReader, lewat console menggunakan class JOptionPane , GUI(graphical user interface) • IF, Nested IF dan switch case merupakan bagian dari Struktur kontrol keputusan, yang digunakan untuk memilih bagian dari code yang akan dieksekusi.. 3.. Tugas Pendahuluan 1.. 4.. Jelaskan penggunaan class BufferedReader dan class JOptionPane untuk mendapatkan input dari keyboard. Berikan masing-masing contoh program sederhana yang menggunakan class-class tersebut. 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(); 11.

} 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) { 12.

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(); 13.

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; 14.

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(); 15.

} 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 16.

MODUL 4 PERULANGAN DAN PROGRAM REKURSIF 1.. Tujuan • •. 2.. Dasar Teori • •. 3.. 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. Tugas Pendahuluan 1. 2.. 4.. Memahami perulangan (loop) dengan Java Memahami fungsi Rekursif. Jelaskan beberapa struktur kontrol perulangan yang ada Jelaskan perbedaan Rekursif dan Iterasi. 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 : "); 17.

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"); 18.

} }. 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() { 19.

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"); 20.

} 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) { 21.

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 { 22.

public static void main(String[ ] args) { System.out.print("Masukkan bilangan yang akan diFAKTORIAL-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'); } 23.

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. 2.. 3.. Buat sebuah program yang mencetak nama Anda selama seratus kali. Buat tiga versi program ini menggunakan while loop, do while dan for loop Hitung pangkat sebuah nilai berdasarkan angka dan nilai pangkatnya. Buat tiga versi dari program ini menggunakan while loop, do while dan for loop Buat program AnagramRekursif , output diharapkan sebagai berikut :. 24.

MODUL 5 AKSES TERHADAP KELAS DAN UNSUR PEWARISAN 1.. Tujuan • • •. 2.. Dasar Teori •. 3.. 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. Tugas Pendahuluan 1. 2.. 4.. Memahami visibility Memahami Pewarisan (Inheritance) Memahami Antarmuka (interface). Sebutkan perbedaan public, private, protected dan default Apa yang dimaksud dengan pewarisan (inheritance) ? Berikan contoh. 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; 25.

} // 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; 26.

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

// 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 28.

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() { 29.

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

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; 31.

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

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"); 33.

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."); 34.

} 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. 35.

MODUL 6 ARRAY, VECTOR DAN MATRIX 1.. Tujuan • • •. 2.. Dasar Teori • •. 3.. Mendeklarasikan dan membuat array, vector, matrix Mengakses elemen-elemen di dalam array, vector, matrix Menentukan jumlah elemen dalam sebuah array, vector, matrix. Array(larik) adalah variabel yang dapat menyimpan sebuah data list, kemudian memanipulasinya dengan lebih efektif. Matrix merupakan array multidimensi. 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? "); 36.

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); } 37.

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(""); 38.

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

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() { 40.

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 Berikut ini adalah array multidimensi yang menyatakan isi dari sebuah buku alamat :. 2.. 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 41.

MODUL 7 SORTING DAN SEARCHING 1.. Tujuan • •. 2.. Dasar Teori •. •. 3. 1. a. b. c. d. e.. 4.. Mengorganisasikan data dengan cara mengurutkan Mencari data-data yang telah terurut (sorted). 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.. Tugas Pendahuluan Jelaskan dan beri contoh pengurutan data menggunakan metode : Bubble Sort Selection Sort Insertion Sort ShellSort Quick Short. Praktikum. Percobaan 1 . Pengurutan data import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; 42.

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

+ " 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)); 44.

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

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

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(ukuran1)); 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); 47.

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

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

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

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

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.. 2.. Buat program dengan inputan NIM (empat digit terakhir), nama, dan fakultas untuk beberapa mahasiswa, kemudian lakukan sorting terhadap inputan berdasarkan NIMnya! 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. 52.

MODUL 8 STACK, QUEUE, COLLECTIONS,ARRAYLIST, SET. 1. •. Tujuan Memahami Abstrak Data Type (ADT) Statis yaitu Stack, Queue, Collections, ArrayList dan Set. 2.. Dasar Teori. •. Stack (Tumpukan) dapat dibayangkan sebagai suatu keranjang dimana hanya dat terakhir yang dapat diperoleh kembali dengan satu langkah. Data di bawah hanya dapat diambil jika data di sebelah atasnya telah diambil (dikeluarkan) terlebih dahulu, sehingga struktur data ini dapat dikatakan LIFO (Last In First out). Queue (antrian) apada kenyataannya misal dijumpai pada antrian karcis untuk membeli tiket, berlaku konsep FIFO (First In First Out).. •. 3.. Tugas Pendahuluan. 1.. Jelaskan apa yang dimaksud dengan a. Stack b. Queue c. Collection d. ArrayList e. Set. 4.. Praktikum. Percobaan 1. Program Tumpukan (Stack) package myStack; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Stack; public class Tumpukan { 53.

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(); 54.

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

// 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 : "); 56.

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

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

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; 59.

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 { 60.

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

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>(); 62.

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

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; 64.

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."); }} 65.

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. 37+. 2–9. 29-. 8*7. 87*. 9/3. 93/. Misal : algoritma 3 7 + indeks 2 1 0. Stack + 7 3. process add push operand push operand. 66.

MODUL 9 SINGLY LINKED LIST & DOUBLY LINKED LIST 1. • • 2.. Tujuan Mendeklarasikan dan membuat linked list Memahami implementasi berbagai macam linked list. 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. 67.

kepala= new Gerbong; //membuat sebuah node dengan nama kepala kepala->next==NULL; //pointer milik kepala diarahkan ke NULL kepa la - >da t a =1 0 1 ; //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 e ko r - > n e x t = b a r u ; //menyambung node paling akhir/ekor ke node baru eko r=ba ru; //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. 68.

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

MENAMPILKAN ISI NODE Untuk menampilkan isi suatu node dengan cara mengakses field yang ada di dalam node tersebut. Yaitu dengan  Contoh : bantu =head; while(bantu!=NULL) { print(“%i ”,bantu->data); bantu=bantu->next; }. 3.. Tugas Pendahuluan. 1. 2.. Apa yang dimaksud dengan List (Senarai) 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++; 70.

} 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(); } } 71.

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; 72.

// 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; 73.

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

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

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() { 76.

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; 77.

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

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(); 79.