Program Heap Sort

class MyNode {
private int iData;

public MyNode(int key) {
iData = key;
}

public int getKey() {
return iData;
}

}

public class HeapSort {
private MyNode[] heapArray;

private int maxSize;

private int currentSize; // number of items in array

public HeapSort(int mx) {
maxSize = mx;
currentSize = 0;
heapArray = new MyNode[maxSize];
}

public MyNode remove()
{
MyNode root = heapArray[0];
heapArray[0] = heapArray[--currentSize];
trickleDown(0);
return root;
}

public void trickleDown(int index) {
int largerChild;
MyNode top = heapArray[index];
while (index < currentSize / 2)
{
int leftChild = 2 * index + 1;
int rightChild = leftChild + 1;
// find larger child
if (rightChild < currentSize
&&
heapArray[leftChild].getKey() < heapArray[rightChild]
.getKey())
largerChild = rightChild;
else
largerChild = leftChild;

if (top.getKey() >= heapArray[largerChild].getKey())
break;

heapArray[index] = heapArray[largerChild];
index = largerChild;
}
heapArray[index] = top;
}

public void displayHeap() {
int nBlanks = 32;
int itemsPerRow = 1;
int column = 0;
int currentIndex = 0;
while (currentSize > 0)
{
if (column == 0)
for (int k = 0; k < nBlanks; k++)
System.out.print(‘ ‘);
System.out.print(heapArray[currentIndex].getKey());

if (++currentIndex == currentSize) // done?
break;

if (++column == itemsPerRow) // end of row?
{
nBlanks /= 2;
itemsPerRow *= 2;
column = 0;
System.out.println();
} else
for (int k = 0; k < nBlanks * 2 – 2; k++)
System.out.print(‘ ‘); // interim blanks
}
}

public void displayArray() {
for (int j = 0; j < maxSize; j++)
System.out.print(heapArray[j].getKey() + ” “);
System.out.println(“”);
}

public void insertAt(int index, MyNode newNode) {
heapArray[index] = newNode;
}

public void incrementSize() {
currentSize++;
}

public static void main(String[] args){
int size, i;

size = 10;
HeapSort theHeap = new HeapSort(size);

for (i = 0; i < size; i++) {
int random = (int) (java.lang.Math.random() * 10);
MyNode newNode = new MyNode(random);
theHeap.insertAt(i, newNode);
theHeap.incrementSize();
}

System.out.print(“Random: “);
theHeap.displayArray();
for (i = size / 2 – 1; i >= 0; i–)
theHeap.trickleDown(i);

System.out.print(“Heap:   “);
theHeap.displayArray();
theHeap.displayHeap();
for (i = size – 1; i >= 0; i–) {
MyNode biggestNode = theHeap.remove();
theHeap.insertAt(i, biggestNode);
}
System.out.print(“\n\nSorted: “);
theHeap.displayArray();
}
}

Program Quick Sort

import java.util.*;

class Node{
int data;
boolean status;

public Node(){
status = false;
}
}

public class QuickSort {
static int bintang;
public static void main(String[] args){
Scanner input = new Scanner (System.in);

Node[] angka;
System.out.println(“Masukkan bilangan (dipisah spasi) :”);
String bil = input.nextLine();
String[] in = bil.split(” “);

angka = new Node[in.length];
for(int i=0;i<in.length;i++){
angka[i] = new Node();
angka[i].data = Integer.parseInt(in[i]);
}

quickSort(angka);
System.out.println(“Hasil sorting :”);
cetak(angka);
}

static void cetak(Node[] angka){

for(int i=0;i<angka.length;i++){
if(i==bintang)
System.out.print(“*   “);
else  System.out.print(angka[i].data+”   “);
}
System.out.println();
}

static void quickSort (Node[] angka){
int pivot,pivotIndex,pointer;

if(angka.length>=1){

pivotIndex = 0;
pointer = angka.length;
boolean kanan = true;

while(pivotIndex<angka.length-1){
pivot = angka[pivotIndex].data;
pointer–;
while(pointer!=pivotIndex){
if(kanan){
if(angka[pointer].data<pivot){
angka[pivotIndex].data = angka[pointer].data;
int temp = pivotIndex;
pivotIndex = pointer;
pointer = temp+1;
kanan = false;
}
else  pointer–;
}
else{
if(angka[pointer].data>pivot){
angka[pivotIndex].data = angka[pointer].data;
int temp = pivotIndex;
pivotIndex = pointer;
pointer = temp-1;
kanan = true;
}
else  pointer++;
}
bintang = pivotIndex;
System.out.println(“Pivot = “+pivot);
cetak(angka);
System.out.println();
}
angka[pivotIndex].data = pivot;
angka[pivotIndex].status = true;

bintang = angka.length;
cetak(angka);
System.out.println();

pivotIndex = 0;
while(pivotIndex<angka.length && angka[pivotIndex].status)
pivotIndex++;
pointer = pivotIndex + 1;
while(pointer<angka.length && !angka[pointer].status)
pointer++;
kanan = true;
}
}
}
}

Program Merge Sort

public class MergeSort {
private long[] theArray;

private int nElems;

public MergeSort(int max) {
theArray = new long[max];
nElems = 0;
}

public void insert(long value) {
theArray[nElems] = value; // insert it
nElems++; // increment size
}

public void display() {
for (int j = 0; j < nElems; j++)
System.out.print(theArray[j] + ” “);
System.out.println(“”);
}

public void mergeSort() {
long[] workSpace = new long[nElems];
recMergeSort(workSpace, 0, nElems – 1);
}

private void recMergeSort(long[] workSpace, int lowerBound, int upperBound) {
if (lowerBound == upperBound) // if range is 1,
return; // no use sorting
else { // find midpoint
int mid = (lowerBound + upperBound) / 2;
// sort low half
recMergeSort(workSpace, lowerBound, mid);
// sort high half
recMergeSort(workSpace, mid + 1, upperBound);
// merge them
merge(workSpace, lowerBound, mid + 1, upperBound);
}
}

private void merge(long[] workSpace, int lowPtr, int highPtr, int upperBound) {
int j = 0; // workspace index
int lowerBound = lowPtr;
int mid = highPtr – 1;
int n = upperBound – lowerBound + 1; // # of items

while (lowPtr <= mid && highPtr <= upperBound)
if (theArray[lowPtr] < theArray[highPtr])
workSpace[j++] = theArray[lowPtr++];
else
workSpace[j++] = theArray[highPtr++];

while (lowPtr <= mid)
workSpace[j++] = theArray[lowPtr++];

while (highPtr <= upperBound)
workSpace[j++] = theArray[highPtr++];

for (j = 0; j < n; j++)
theArray[lowerBound + j] = workSpace[j];
}

public static void main(String[] args) {
int maxSize = 100; // array size
MergeSort arr = new MergeSort(maxSize); // create the array

arr.insert(14);
arr.insert(21);
arr.insert(43);
arr.insert(50);
arr.insert(62);
arr.insert(75);
arr.insert(14);
arr.insert(2);
arr.insert(39);
arr.insert(5);
arr.insert(608);
arr.insert(36);
System.out.print(“Sebelum disorting : “);
arr.display();
arr.mergeSort();
System.out.print(“\nSetelah disorting : “);
arr.display();
System.out.println();
}
}

Program Insertion Sort

import java.util.*;

class node{
int data;
node next,prev;
public node(int n){
data = n;
next = prev = null;
}
}

class list{
node head,tail;
public list(){
head = tail = null;
}

void addLast(int n){
node input = new node(n);
if(head==null){
head = tail = input;
}
else{
tail.next = input;
input.prev = tail;
tail = input;
}
}

public void insertion()
{
node flag=head;
node pencari;
int temp;
do
{
if (flag.next.data<flag.data)
{
pencari=flag;
while (flag.next.data>pencari.data)
{
pencari=pencari.prev;
}
temp=pencari.data;
pencari.data=flag.next.data;
flag.next.data=temp;
}
flag=flag.next;
} while (flag.next!=null);
}

void cetak (){
node temp = head;
while(temp!=null){
System.out.print(temp.data+” “);
temp = temp.next;
}
}
}

public class InsertionSort{
public static void main (String[] args){
Scanner input = new Scanner (System.in);
System.out.print(“Jumlah bilangan : “);
int n = input.nextInt();
list angka = new list();

System.out.println(“Masukkan bilangan :”);
for(int i=0;i<n;i++) {
System.out.print(“=> “);
int a = input.nextInt();
angka.addLast(a);
}

System.out.println(“Urutan bilangan dari kecil ke besar :”);
for(int i=0;i<n-1;i++){
angka.insertion();
}
angka.cetak();
System.out.println();
}
}

Program Selection Sort

import java.util.*;

class node {
int data;
node next,prev;
public node (int n) {
data = n;
next = prev = null;
}
}

class list {
node head,tail;
public list () {
head = tail = null;
}

void addLast(int n) {
node input = new node(n);
if(head==null) {
head = tail = input;
}
else {
tail.next = input;
input.prev = tail;
tail = input;
}
}

void urutkan() {
node satu = head;
while(satu!=tail && satu!=null) {
node dua = satu, jalan = satu.next;
while(jalan!=null){
if(jalan.data<dua.data)
dua = jalan;
jalan = jalan.next;
}
if(satu!=dua)
tukar(satu,dua);

satu = satu.next;
}
}

void tukar(node satu,node dua) {
int temp = dua.data;
dua.data = satu.data;
satu.data = temp;
}

void cetak () {
node temp = head;
while(temp!=null) {
System.out.print(temp.data+” “);
temp = temp.next;
}
}
}

public class SelectionSort {
public static void main (String[] args) {
Scanner input = new Scanner (System.in);
System.out.print(“Jumlah bilangan : “);
int n = input.nextInt();
list angka = new list();

System.out.println(“Masukkan bilangan :”);
for(int i=0;i<n;i++) {
System.out.print(“>> “);
int a = input.nextInt();
angka.addLast(a);
}

System.out.println(“Urutan bilangan dari kecil ke besar :”);
angka.urutkan();
angka.cetak();
System.out.println();
}
}

Program Bubble Sort

import java.util.*;

class node {
int data;
node next,prev;
public node (int n) {
data = n;
next = prev = null;
}
}

class list {
node head,tail;
public list () {
head = tail = null;
}

void addLast(int n) {
node input = new node(n);
if(head==null) {
head = tail = input;
}
else {
tail.next = input;
input.prev = tail;
tail = input;
}
}

void urutkan() {
node satu = head, dua = head, ulang = head;
while(ulang!=tail){
satu = head;
while(satu != null){
dua = satu.next;
if(dua != null){
if(dua.data<satu.data)
tukar(satu,dua);
}
satu=satu.next;
}
ulang=ulang.next;
}

}

void tukar(node satu,node dua) {
int temp = dua.data;
dua.data = satu.data;
satu.data = temp;
}

void cetak () {
node temp = head;
while(temp!=null) {
System.out.print(temp.data+” “);
temp = temp.next;
}
}
}

public class BubleSort {
public static void main (String[] args) {
Scanner input = new Scanner (System.in);
System.out.print(“Jumlah bilangan : “);
int n = input.nextInt();
list angka = new list();

System.out.println(“Masukkan bilangan :”);
for(int i=0;i<n;i++) {
System.out.print(“>> “);
int a = input.nextInt();
angka.addLast(a);
}

System.out.println(“Urutan bilangan dari kecil ke besar :”);
for(int i=0;i<n-1;i++){
angka.urutkan();
}
angka.cetak();
System.out.println();
}
}

Program Binary Search

import java.util.Scanner;

class ArrayQ{
int[] data;
int pj;

public ArrayQ(int ArrayQ){
data = new int[ArrayQ];
pj=0;
}

void insert(int angka){
int i;
for(i=0; i<pj; i++){
if(data[i] > angka)
break;
}

for(int j=pj; j>i; j–){
data[j] = data[j-1];
}
data[i] = angka;
pj++;
}

void display(){
for(int i=0; i<pj; i++)
System.out.print(data[i] + ” “);
System.out.println();
}

void searching(int key){
System.out.println(“\nProses Pencarian Angka “+key);

int bawah=0;
int tengah;
int atas = pj-1;

while(atas>=bawah){
tengah=(bawah+atas)/2;
if(data[tengah]==key){
System.out.println(“Status : ditemukan!!”);
return;
}
else{
if (data[tengah]<key) bawah = tengah+1;
else atas = tengah-1;
}
}

System.out.println(“Status : tidak ditemukan!!”);
}
}

public class BinarySearch{
public static void main(String[] args){
System.out.println(“^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^”);
System.out.println(” Binary Search\n “);
System.out.println(“^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^”);
Scanner input = new Scanner(System.in);
System.out.print(“Jumlah angka = “);
int jumlah = input.nextInt();

ArrayQ list;
list = new ArrayQ(jumlah);

System.out.println(“Masukkan angka :”);
int[] angka=new int[jumlah];
for(int i=0;i<jumlah;i++){
System.out.print(“>> “);
angka[i] = input.nextInt();
list.insert(angka[i]);
}

list.display();
System.out.println(“\nDicari : “);
int cari = input.nextInt();

list.searching(cari);
// System.out.println(“Status : ditemukan!!”);
// System.out.println(“Status : tak ditemukan!!”);

System.out.println();
}
}

Program Linear Search

import java.util.Scanner;

class Node {
int data,index;
Node next;
public Node(int data,int index){
this.data=data;
this.index=index;
}
}

class LinkedList{
Node head, tail;

void addLast(int nilai,int id){
Node input=new Node(nilai,id);

if(head==null){
head=tail=input;
}
else{
tail.next=input;
tail=input;
}
}

void display(){
Node temp=head;
while(temp!=null){
System.out.print(temp.data+” “);
temp=temp.next;
}
}

void searching(int key){
Node temp = head;
System.out.println(“\nProses Pencarian Angka “+key);
while(temp!=null){
if(temp.data==key){
System.out.println(“Status : ditemukan di indeks ke-”+temp.index);
break;
}
else
temp=temp.next;
}
if(temp==null)
System.out.println(“Status : tak ditemukan!!”);

}

}

public class LinearSearch{
public static void main(String[] args){
System.out.println(“^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^”);
System.out.println(” Linear Search\n “);
System.out.println(“^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^”);

LinkedList list=new LinkedList();
Scanner input = new Scanner(System.in);
System.out.print(“Jumlah angka = “);
int jumlah = input.nextInt();
input = new Scanner(System.in);
System.out.println(“Masukkan angka :”);
int angka;
for(int i=0;i<jumlah;i++){
System.out.print(“>> “);
angka = input.nextInt();
list.addLast(angka,i); // nama team disimpan dalam queue
}

list.display();
System.out.print(“\nDicari : “);
int cari = input.nextInt();
list.searching(cari);
System.out.println();
}
}

Program Simulasi Pertandingan Sistem Gugur

import java.util.*;
/* Program Simulasi Pertandingan Sistem Gugur Khusus Jumlah Team 2^n  */

class Node {
String nama;
int level;
Node next;
Node left,right,parent;
public Node(String n) {
nama = n;
level = 0;
next = left = right = parent= null;
}
public Node(){
}
void setLevel(int n){                // memberi level di tiap node yang se-level
level = n;                        // dengan traversal preorder
if(left!=null)
left.setLevel(n+1);
if(right!=null)
right.setLevel(n+1);
}
}

class Queue {
Node head,tail;

public Queue () {
head = tail = null;
}

void addQueue (Node baru) {
if(head==null){
head = tail = baru;
}
else {
tail.next = baru;
tail = baru;
}
}
Node find(String cari) {
Node temp = head;
while(temp!=null) {
if(temp.nama.equalsIgnoreCase(cari))
return temp;
temp = temp.next;
}
return null;
}
}
class tree {
Node root;
public tree(Node n){
root = n;
}

void proses (Queue antri,String tim1,String tim2) {
Node satu = antri.find(tim1);
Node dua = antri.find(tim2);
int j = 0;
while(satu.parent!=dua.parent){            // selama parent ga sama, dia naik terus
j++;                                // j untuk menghitung banyak team yang harus dikalahkan
satu = satu.parent;
dua = dua.parent;
}
String babak=”penyisihan”;                // default babak : penyisihan
if(satu.parent.level==0)
babak = “final”;
else if(satu.parent.level==1)
babak = “semi final”;
else if(satu.parent.level==2)
babak = “perempat final”;
System.out.println(tim1+” dan “+tim2+” dapat bertemu di babak “+babak);
System.out.println(tim1+” harus mengalahkan “+j+” tim sebelum bisa bertemu dengan “+tim2);
}
}

public class tanding {
public static void main (String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“Jumlah tim = “);
int jumlah = input.nextInt();
input = new Scanner(System.in);
System.out.println(“Masukkan nama tim :”);
String nama = “”;
Queue antri = new Queue();
for(int i=0;i<jumlah;i++){
System.out.print(“Tim ke-”+(i+1)+” >> “);
nama = input.nextLine();
antri.addQueue(new Node(nama));        // nama team disimpan dalam queue
}

tree jadwal = buatTree(antri);            // buat tree dengan nama2 yang sudah diinputkan tadi
if(jadwal.root!=null)
jadwal.root.setLevel(0);
String pil=”y”;
while(pil==”y” || pil==”Y”) {
System.out.print(“\nMasukkan nama tim 1 >> “);
String tim1 = input.nextLine();
System.out.print(“Masukkan nama tim 2 >> “);
String tim2 = input.nextLine();
jadwal.proses(antri,tim1,tim2);
System.out.print(“\nUlang lagi (y)? “);
pil = input.nextLine();
}
}

static tree buatTree(Queue antri){
Node temp = antri.head;
while(temp.next!=null) {        // bikin parent sampe final
Node p = new Node();
if(temp.parent==null && temp.next.parent==null) {
temp.parent = temp.next.parent = p;        // membuat parent dari 2 anak
p.left = temp;                            // left diarahkan lagi ke anak kiri
p.right = temp.next;                    // right diarahkan lagi ke anak kanan
}
antri.addQueue(p);
temp = temp.next.next;
}
return new tree(temp);
}
}

program family tree

import java.util.*;
class Node{
String nama;
int level;
Node parent,sibling,anak;
linkedList child;                // linkedlist yg selevel
public Node(String n){
nama = n;
parent = sibling = anak = null;
child = null;
level = 0;
}
void view(Node berhenti){        // u/ ngeprint anaknya root
// anak root
System.out.println(nama);
// anaknya anak root dst
if(anak!=null){
for(int i=0;i<anak.level;i++)
System.out.print(“   “);
anak.view(anak);        // kalo masih ada yang levelnya dibwh anak root, print
}
// sodara anaknya anak root dst
if(sibling!=berhenti && sibling.parent==this.parent){
for(int i=0;i<sibling.level;i++)
System.out.print(“   “);
sibling.view(berhenti);
}

}
}

class linkedList {
Node head,tail;
public linkedList (){
head = tail = null;
}

Node find(String cari){
Node temp=head;
do{
if(temp.nama.contains(cari)){
return temp;
}
temp = temp.sibling;
}while(temp!=head && temp!=null);
return null;
}
void add(Node input){
// u/ nambah linkedlist child
if(head.child==null){
head.child = new linkedList();
head.child.head = input;
head.child.tail = input;
input.sibling = input;
}
else{
Node temp = head.child.head;
while(temp.parent!=input.parent && temp.sibling!=head.child.head)
temp = temp.sibling;
input.sibling = temp.sibling;
temp.sibling = input;
}
// u/ ngehubungin parent dan anaknya
if(input.parent.anak==null)
input.parent.anak = input;
input.level = input.parent.level + 1;
System.out.println(“Berhasil memasukkan “+input.nama+” sebagai anak dari “+input.parent.nama);
}
}

class Tree{
Node root;
public Tree(){
root = null;
}
void insert(String a,String b){
if(b.equals(“”)){        // sbg root
if(root==null){
root = new Node(a);
System.out.println(“Berhasil memasukkan “+a+” sebagai root”);
}
else
System.out.println(“Input Error!!”);
}
else if(root.nama.contains(b)){        // nambah anak root
if(!menikah(root))
return;
Node baru = new Node(a);
baru.parent = root;
baru.level = 1;
if(root.child==null){
root.child = new linkedList();    // nambahnya dg buat linkedlist baru
root.child.head = baru;
root.child.tail = baru;
root.anak = baru;
baru.sibling = baru;
}
else{
root.child.tail.sibling = baru;
baru.sibling = root.child.head;
root.child.tail = baru;
}
System.out.println(“Berhasil memasukkan “+a+” sebagai anak dari “+b);
}
else{    // nambah cucu root dan seterusnya
linkedList temp = findList(b);
Node input = new Node(a);
if(temp != null){
if(!menikah(temp.find(b)))
return;
input.parent = temp.find(b);
temp.add(input);         // nambah dari linkedlist
}
else
System.out.println(“Tidak ada anggota keluarga bernama “+b);
}
}

void view(){
if(root==null){
System.out.println(“Belum ada data”);
}
else{
System.out.println(root.nama);            // ngeprint root
if(root.anak!=null){
for(int i=0;i<root.anak.level;i++)
System.out.print(“   “);
root.anak.view(root.anak);
}
}
}
linkedList findList (String cari){
linkedList temp = root.child;
while(temp!=null){
if(temp.find(cari)!=null)
return temp;
temp = temp.head.child;
}
return null;
}
void findAll(String nama){
if(root.nama.equals(nama)){
System.out.println(nama+” adalah root”);
}
else{
linkedList temp = findList(nama);
if(temp!=null){
Node p = temp.find(nama);
if(p.sibling==p)
System.out.println(“Tidak ada anggota keluarga yang selevel dengan “+nama);
else{
p = p.sibling;
System.out.print(“Anggota keluarga yang selevel dengan “+nama+” adalah “+p.nama);
while(p.sibling!=temp.find(nama)){
System.out.print(“, “+p.sibling.nama);
p = p.sibling;
}
}
}
else
System.out.println(“Tidak ada anggota keluarga bernama “+nama);
System.out.println();
}
}
void relation(String a,String b){
linkedList temp = findList(a);
linkedList temp2 = findList(b);
if(temp==null || temp2==null){
if(!(root.nama.contains(a) || root.nama.contains(b))){
System.out.println(“Input Error !!”);
return;
}
}
Node satu=null,dua=null;
//kalo salah satunya root
if(temp==null){
satu = root;
dua = temp2.find(b);
}
else if(temp2==null){
dua = root;
satu = temp.find(a);
}
//kalo dua-duanya bukan root
else{
satu = temp.find(a);
dua = temp2.find(b);
}

if(satu!=null && dua!=null){
// dikondisikan satu paling muda(levelnya besar)
if(dua.level>satu.level){
Node s = satu;
satu = dua;
dua = s;
}
if(satu.level == dua.level){
if(satu.parent==dua.parent)
System.out.println(a+” adalah saudara kandung “+b);
else  System.out.println(a+” adalah saudara sepupu “+b);
}
else{
int selisih = satu.level – dua.level;
if(selisih==1){
if(satu.parent==dua)
System.out.println(dua.nama+” adalah orangtua dari “+satu.nama);
else  System.out.println(satu.nama+” adalah keponakan “+dua.nama);
}
else if(selisih==2){
System.out.println(satu.nama+” adalah cucu “+dua.nama);
}
else if(selisih==3){
System.out.println(satu.nama+” adalah cicit “+dua.nama);
}
else{
System.out.println(satu.nama+” adalah canggah “+dua.nama);
}
}
}
}
void marry(String a,String b){
linkedList temp = findList(a);
Node m = null;
if(temp==null){
if(root.nama.equals(a)){
m = root;
}
else{
System.out.println(“Input error !!”);
return;
}
}
else
m = temp.find(a);
m.nama = m.nama + ” ” + b;
System.out.println(“cie..cie.. , akhirnya “+a+” nikah juga sama si “+b);
}
boolean menikah(Node cek){
StringTokenizer st = new StringTokenizer(cek.nama);
if(st.countTokens()!=2){
System.out.println(cek.nama+” belum menikah !!”);
return false;
}
return true;
}
}

public class SilsilahKeluargaKlp76{
public static void main(String[] args){
Scanner input = new Scanner (System.in);
String perintah;
Tree silsilah = new Tree();
StringTokenizer st;
while(true){
System.out.print(“command >> “);
perintah = input.nextLine();
while(perintah.length()<10)
perintah = perintah + ” “;
if(perintah.substring(0,6).equalsIgnoreCase(“insert”)){
st = new StringTokenizer(perintah.substring(7));
if(st.countTokens()==1){
silsilah.insert(st.nextToken(),”");
}
else{
silsilah.insert(st.nextToken(),st.nextToken());
}
}
else if(perintah.substring(0,4).equalsIgnoreCase(“view”)){
System.out.println();
silsilah.view();
System.out.println();
}
else if(perintah.substring(0,8).equalsIgnoreCase(“relation”)){
st = new StringTokenizer(perintah.substring(9));
silsilah.relation(st.nextToken(),st.nextToken());
}
else if(perintah.substring(0,8).equalsIgnoreCase(“find_all”)){
st = new StringTokenizer(perintah.substring(9));
silsilah.findAll(st.nextToken());
}
else if(perintah.substring(0,5).equalsIgnoreCase(“marry”)){
st = new StringTokenizer(perintah.substring(6));
silsilah.marry(st.nextToken(),st.nextToken());
}
else
System.out.println(“Nginput yang bener donkZzz!!!”);
}
}
}