TREE 1. Tujuan
MODUL 11 HASH TABLE
1. Tujuan
• Mengimplementasikan konsep Hash pada Java
• Memahami Enumeration, Iterator dan Interface Iterable
• Mengimplementasikan penggunaan Iterator untuk Penelusuran Table Hash
2. Dasar Teori
• Hash Table adalah struktur data yang sering digunakan untuk mengimplementasikan ADT Dictionary, yaitu ADT yang hanya mengizinkan pencarian, penyisipan, dan penghapusan elemen-elemen yang ada didalamnya
3. Tugas Pendahuluan
1. Apa yang dimaksud dengan :
a. Hash table
b. Enumeration
c. Iterator
d. Interface Iterable
2. Bagaimana cara menggunakan iterator untuk penelusuran table hash
4. Praktikum
Percobaan 1. HashAssociation package packageHashTable;
class HashAssociation<K extends Number, V> { protected K theKey;
protected V theValue; protected K key; protected V value;
HashAssociation() { this.theKey = key; this.theValue = value; } V setValue(V value) { V oldValue = theValue; theValue = value; return oldValue; } K getTheKey() { return theKey; }
void setTheKey(K theKey) { this.theKey = theKey; }
V getTheValue() { return theValue; }
void setTheValue(V theValue) { this.theValue = theValue; } } Percobaan 2. HashTable package packageHashTable; import java.util.Vector;
public class HashTable<K, V> { int count;
int hash;
final double maximumLoadFactor = 0.5;
public static HashAssociation<Integer, String> DATA; public static Vector<HashAssociation<Integer, String>> data;
public HashTable(int initialCapacity) { if (initialCapacity > 0) {
System.out.print("Kapasitas Hashtable positip."); data = new Vector<HashAssociation<Integer, String>>(); data.setSize(initialCapacity); count = 0; } } public HashTable() { this(100); }
protected int locate(K key) {
hash = Math.abs(key.hashCode() % data.size()); while (data.get(hash) != null) {
if (data.get(hash) != null) {
if (key.equals(data.get(hash).getTheKey())) return hash;
}
hash = (1 + hash) % data.size(); }
return hash; }
public String put(K key, V value) {
if (maximumLoadFactor * data.size() <= (1 + count)) { System.out.println("Hash Table is FULL"); }
int hash = locate(key); if (data.get(hash) == null) {
DATA = new HashAssociation<Integer, String>(); data.set(hash, DATA);
count++; return null; } else {
HashAssociation<Integer, String> a = data.get(hash); String theValue = a.getTheValue();
String oldValue = theValue; a.setValue((String) theValue); return oldValue;
} }
public int containsValueByKey(K key) { int hash = locate(key);
if (data.get(hash) != null) return -99; else
return hash; }
public Vector<HashAssociation<Integer, String>> getData() { return data;
}
public void setDATA(K key, V value) { put(key, value);
}
public boolean containsValue(K key) { int hash = locate(key); return data.get(hash) != null; }
public String get(K key) { int hash = locate(key); if (data.get(hash) == null) return null; return data.get(hash).getTheValue(); } } Percobaan 3. TesthashTable package packageHashTable; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader;
public class TestHashTable {
HashTable<Integer, String> ht; public static void main(String[] args) {
HashTable<Integer, String> ht = new HashTable<Integer, String>();
System.out.print("\nBerapa data yang akan dimasukkan? "); int jData = inputData();
for (int i = 0; i < jData; i++) {
System.out.print("Masukkan kunci ke-" + (i + 1) + " : ");
int key = inputData();
System.out.print("Masukkan nilai ke-" + (i + 1) + " : "); String value = inputNilai();
ht.setDATA(key, value); }
System.out.println("Data-data sudah masuk. Mau memeriksa ? ");
System.out.print("Masukkan kunci yang dicari : "); int kunci = inputData();
int kunciPencarian = ht.containsValueByKey(kunci); if (kunciPencarian == -99) {
System.out.print("Data Anda cari tidak ada bok!!"); } else {
System.out.println("Data dengan kunci : " + kunci + " ada!");
} }
private static String inputNilai() { String data = null;
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in)); String stringInput = null;
try { stringInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } data = String.valueOf(stringInput); return data; }
private static int inputData() {
BufferedReader bfr = new BufferedReader(
String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); }
int Data = Integer.valueOf(angkaInput).intValue(); return Data; } } Percobaan 4. AbstractIterator package packageTestVectorIterator; import java.util.Enumeration; import java.util.Iterator;
public abstract class AbstractIterator<E>
implements Enumeration<E>, Iterator<E>, Iterable<E> {
public abstract void reset(); public abstract boolean hasNext(); public abstract E get();
public abstract E next(); public void remove() {
System.out.print("remove() belum diimplementasikan."); }
final public boolean hasMoreElements() {
return hasNext(); }
final public E nextElement() {
return next(); }
public Iterator<E> iterator(VectorIterator<HashAssociation<Integer, String>> vi) {
return this; }
}
Percobaan 5. HashAssociation package packageTestVectorIterator;
class HashAssociation<K extends Number, V> { protected K theKey; protected V theValue; protected K key; protected V value; HashAssociation() { this.theKey = key; this.theValue = value; } V setValue(V value) { V oldValue = theValue; theValue = value; return oldValue; } K getTheKey() { return theKey; }
void setTheKey(K theKey) { this.theKey = theKey; }
V getTheValue() { return theValue; }
void setTheValue(V theValue) { this.theValue = theValue; }
}
Percobaan 6. VectorIterator
import java.util.Iterator; import java.util.Vector;
@SuppressWarnings("hiding")
class VectorIterator<E> extends AbstractIterator<E> { protected Vector<E> theVector;
protected int current; public Iterator<E> iterator() {
return new VectorIterator<E>(); }
public void reset() {
current = 0; }
public boolean hasNext() {
return current < theVector.size(); } public E get() { return theVector.get(current); } public E next() { return theVector.get(current++); } } Percobaan 7. TestIteratorforVector package packageTestVectorIterator; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Iterator; import java.util.Vector;
public class TestIteratorforVector {
static Vector <String> vector = new Vector<String>(); static Iterator<String> i;
System.out.print("Berapa data yang akan dimasukkan? "); int jData = inputData();
for (int i = 0; i < jData; i++) {
System.out.print("Masukkan nama ke-" + (i + 1) + " : "); String value = inputNilai();
vector.add(value); }
System.out.print("Data-data sudah masuk. Mau memeriksa (1) ? "); int periksa = inputData();
if (periksa == 1) tampilData(); }
private static void tampilData() { int j=1;
i = (Iterator<String>) vector.iterator(); while(i.hasNext())
{
System.out.print("\nData ke-" + j + " adalah " + i.next().toString());
j++; }
System.out.println(); }
private static String inputNilai() { String data = null;
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in)); String stringInput = null;
try { stringInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } data = String.valueOf(stringInput); return data; }
private static int inputData() {
BufferedReader bfr = new BufferedReader(
String angkaInput = null; try { angkaInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); }
int Data = Integer.valueOf(angkaInput).intValue(); return Data; } } Percobaan 8. TestVectorIterator_forHash package packageTestVectorIterator; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.Vector;
public class TestVectorIterator_forHAssc extends
VectorIterator<HashAssociation<Integer, String>> { static Vector<HashAssociation<Integer, String>> vector =
new Vector<HashAssociation<Integer, String>>(); public TestVectorIterator_forHAssc
(Vector<HashAssociation<Integer, String>> v) { super();
}
public static void main(String[] args) {
System.out.print("\nBerapa data yang akan dimasukkan? "); int jData = inputData();
for (int i = 0; i < jData; i++) {
HashAssociation<Integer, String> ha =
new HashAssociation<Integer, String>();; System.out.print("Masukkan kunci ke-" + (i + 1) + " : ");
int key = inputData();
System.out.print("Masukkan nilai ke-" + (i + 1) + " : "); String value = inputNilai();
ha.setTheKey(key); ha.setTheValue(value);
vector.add(ha); }
System.out.print("\nData-data sudah masuk. Mau memeriksa (1)? ");
int periksa = inputData(); if (periksa == 1)
tampilData(); }
private static void tampilData() { int j = 1;
for (HashAssociation<Integer, String> ha : vector){ System.out.println("Data ke-" + j + " KEY : "
+ ha.getTheKey().toString() + " VALUE : " + ha.getTheValue().toString()); j++; } }
private static String inputNilai() { String data = null;
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in)); String stringInput = null;
try { stringInput = bfr.readLine(); } catch (IOException e) { e.printStackTrace(); } data = String.valueOf(stringInput); return data; }
private static int inputData() {
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in)); String angkaInput = null;
try {
angkaInput = bfr.readLine(); } catch (IOException e) {
}
int Data = Integer.valueOf(angkaInput).intValue(); return Data;
} }
5. Tugas Praktikum
Buat Kesimpulan dengan deskripsi tentang penggunaan struktur data hash table dari beberapa percobaan diatas
MODUL 12
GRAPH
1.Tujuan
• Mendeklarasikan dan membuat graph
• Mengakses elemen-elemen di dalam graph
• Menentukan jumlah elemen dalam sebuah graph
2. Dasar Teori
• Graph merupakan salah satu dari beberapa struktur data yang paling sering diaplikasikan dalam pemrograman komputer. Jika memutuskan untuk menggunakan penyimpanan data yang bersifat eksternal (external storage), tidak membutuhkan graph, tetapi untuk permasalahan dimana diperlukan representasi internal dalam memori komputer untuk suatu struktur data, graph harus digunakan. Graph terdiri dari graph tidak berbobot (unweighted graph) dan graph berbobot (weighted graph)
3. Tugas Pendahuluan
1. Jelaskan pengertian algoritma-algoritma berikut ini: a. Algoritma DFS (Depth First Search)
b. Algoritma BFS (Breath First Search) c. Algoritma MST (Minimum Spanning Tree)
d. Algoritma pengurutan topologi pada graph berarah (directed graph) 4. Praktikum
Percobaan 1. Graph package DFS_BFS_MFS; class Graph
{
private final int MAX_VERTS = 20; private Vertex vertexList[]; // Daftar simpul.
private int adjMat[][]; // adjacency matrix private int nVerts; // jumlah simpul saat ini. private static StackX theStack;
private static QueueX theQueue; // ---
public Graph() // constructor {
vertexList = new Vertex[MAX_VERTS]; // adjacency matrix
adjMat = new int[MAX_VERTS][MAX_VERTS]; nVerts = 0;
for(int j=0; j<MAX_VERTS; j++) // Menginisialisasi adjacency for(int k=0; k<MAX_VERTS; k++) // matrix ke nilai 0. adjMat[j][k] = 0;
theStack = new StackX(); theQueue = new QueueX(); } // end constructor // ---
public void addVertex(char lab) {
vertexList[nVerts++] = new Vertex(lab); }
// ---
public void addEdge(int start, int end) {
adjMat[start][end] = 1; adjMat[end][start] = 1; }
// ---
public void displayVertex(int v) {
System.out.print(vertexList[v].label); }
// ---
public void dfs() // depth-first search { //Mulai dari vertex 0
vertexList[0].wasVisited = true; // Tandai. displayVertex(0); // Tampilkan.
while( !theStack.isEmpty() ) // Hingga stack kosong, {
// Mendapatkan simpul yang
// belum dikunjungi dan berdampingan dengan // simpul yang ada di bagian atas Stack.
int v = getAdjUnvisitedVertex( theStack.peek() ); if(v == -1) // Jika vertex tidak ada,
theStack.pop(); else // Jika vertex ada, {
vertexList[v].wasVisited = true; // Tandai. displayVertex(v); // Tampilkan.
theStack.push(v); // Masukkan (push) ke Stack. }
} // end while // Stack kosong.
for(int j=0; j<nVerts; j++) // Pengaturan-ulang penanda. vertexList[j].wasVisited = false;
} // end dfs // ---
//--- public void bfs() // breadth-first search
{ // Mulai vertex 0
vertexList[0].wasVisited = true; // Tandai displayVertex(0); // Tampilkan.
theQueue.insert(0); // Tambah di bagian belakang. int v2;
while( !theQueue.isEmpty() ) // Hingga queue kosong, {
int v1 = theQueue.remove(); // Hapus vertex di bagian depan. // Hingga tidak ada simpul tetangga yang belum dikunjungi. while( (v2=getAdjUnvisitedVertex(v1)) != -1 )
{ // get one,
vertexList[v2].wasVisited = true; // Tandai. displayVertex(v2); // Tampilkan.
theQueue.insert(v2); // Sisipkan. } // end while
} // end while(queue tidak kosong) //Stack kosong
vertexList[j].wasVisited = false; } // end bfs()
// --- // Mendapatkan simpul yang
// belum dikunjungi dan berdampingan dengan // simpul yang ada di bagian atas Stack. public int getAdjUnvisitedVertex(int v) {
for(int j=0; j<nVerts; j++)
if(adjMat[v][j]==1 && vertexList[j].wasVisited==false) return j;
return -1;
} // end getAdjUnvisitedVert() // ---
public void mps() {
vertexList[0].wasVisited = true; // Tandai. theStack.push(0); // Masukkan (push) ke Stack. while(!theStack.isEmpty() ) // Hingga stack kosong. { // Mendapatkan nilai pada bagian atas (top) stack. int currentVertex = theStack.peek();
// Hingga tidak ada simpul tetangga yang belum dikunjungi. int v = getAdjUnvisitedVertex(currentVertex);
if(v == -1) // Jika tidak ada simpul tetangga lagi. theStack.pop(); // Lakukan pop.
else // Simpul tetangga ada. {
vertexList[v].wasVisited = true; // Tandai. theStack.push(v); // Masukkan (push) ke stack. // Tampilkan lintasan.
displayVertex(currentVertex); // dari currentV displayVertex(v); // ke v
System.out.print(" "); }
} // end while(stack tidak kosong) // Stack kosong
for(int j=0; j<nVerts; j++) // Pengaturan-ulang flags vertexList[j].wasVisited = false;
} // end mst() } // end class Graph
Percobaan 2. QueueX package DFS_BFS_MFS; class QueueX
{
private final int SIZE = 20; private int[] queArray; private int front; private int rear;
public QueueX() // constructor {
queArray = new int[SIZE]; front = 0;
rear = -1; }
public void insert(int j) //Memasukkan item ke bagian belakang queue. {
if(rear == SIZE-1) rear = -1;
queArray[++rear] = j; }
public int remove() // Mengambil item dari bagian depan queue. {
int temp = queArray[front++]; if(front == SIZE)
front = 0; return temp; }
public boolean isEmpty() // Bernilai true queue kosong. {
return ( rear+1==front || (front+SIZE-1==rear) ); }
} // end class Queue Percobaan 3. StackX package DFS_BFS_MFS;
// --- class StackX
{
private final int SIZE = 20; private int[] st;
private int top;
public StackX() // Constructor. {
st = new int[SIZE]; //Membuat array. top = -1;
}
public void push(int j) // Menaruh item ke stack. { st[++top] = j; }
public int pop() // Mengambil item dari stack. { return st[top--]; }
public int peek() // Melihat simpul di atas (top) stack. { return st[top]; }
public boolean isEmpty() // Bernilai true jika stack kosong. { return (top == -1); }
} // end class StackX Percobaan 4. TestGraph package DFS_BFS_MFS;
public class TestGraphDFSandBFSandMFS { public static void main(String[] args) {
Graph theGraph = new Graph(); theGraph.addVertex('A'); // 0 theGraph.addVertex('B'); // 1 theGraph.addVertex('C'); // 2 theGraph.addVertex('D'); // 3 theGraph.addVertex('E'); // 4 theGraph.addEdge(0, 1); // AB theGraph.addEdge(0, 2); // AC theGraph.addEdge(0, 3); // AD theGraph.addEdge(0, 4); // AE theGraph.addEdge(1, 2); // BC theGraph.addEdge(1, 3); // BD theGraph.addEdge(1, 4); // BE theGraph.addEdge(2, 3); // CD theGraph.addEdge(2, 4); // CE theGraph.addEdge(3, 4); // DE System.out.println("\nKUNJUNGAN GRAPH :");
System.out.print("\nKunjungan Dengan DFS (Deep First Searching) : ");
theGraph.dfs(); // depth-first search
System.out.print("\nKunjungan Dengan BFS (Breadth First Searching) : ");
theGraph.bfs(); // depth-first search
System.out.print("\nKunjungan Dengan MFS (Minimum Spanning Tree) : ");
theGraph.mps(); // Minimum Spanning Tree } // end main() } Percobaan 5. Vertex package DFS_BFS_MFS; class Vertex {
public char label; // Label (misal. 'A') public boolean wasVisited;
// ---
public Vertex(char lab) // Constructor. {
label = lab; wasVisited = false; }
// --- } // end class Vertex Percobaan 6. MFS
package MFS_for_WEIGHTGRAPH; public class Edge {
public int srcVert; // index vertex awal. public int destVert; // index vertex akhir. public int distance; // jarak dari src ke dest public Edge(int sv, int dv, int d) // constructor {
srcVert = sv; destVert = dv; distance = d; }
} // end class Edge Percobaan 7. graph MFS
package MFS_for_WEIGHTGRAPH; class Graph
{
private final int MAX_VERTS = 20; private final int INFINITY = 1000000; private Vertex vertexList[]; // daftar vertx private int adjMat[][]; // adjacency matrix private int nVerts; // jumlah vertex saat ini. private int currentVert;
private PriorityQ thePQ;
private int nTree; // jumlah vertex di tree
// --- public Graph() // constructor
{
vertexList = new Vertex[MAX_VERTS]; // adjacency matrix
adjMat = new int[MAX_VERTS][MAX_VERTS]; nVerts = 0;
for(int j=0; j<MAX_VERTS; j++) // Menginisialisasi adjacency for(int k=0; k<MAX_VERTS; k++) // matrix ke nilai 0
adjMat[j][k] = INFINITY; thePQ = new PriorityQ(); } // end constructor
// --- public void addVertex(char lab)
{
vertexList[nVerts++] = new Vertex(lab); }
// --- public void addEdge(int start, int end, int weight) {
adjMat[start][end] = weight; adjMat[end][start] = weight; }
// --- public void displayVertex(int v)
{
System.out.print(vertexList[v].label); }
// --- public void mstw() // Algoritma Minimum Spanning Tree {
currentVert = 0; // start di 0
while(nTree < nVerts-1) // selama tidak ada verts di tree { // Letakkan currentVert di tree
vertexList[currentVert].isInTree = true; nTree++;
// Sisipkan lintasan (edge) yang berdampingan // dengan currentVert ke dalam PQ
for(int j=0; j<nVerts; j++) // Untuk setiap vertex, {
if(j==currentVert) // Lompati jika sudah dilewati. continue;
if(vertexList[j].isInTree) // Lompati jika ada di tree continue;
int distance = adjMat[currentVert][j];
if( distance == INFINITY) // Lompati jika tidak ada lintasan (edge) continue;
putInPQ(j, distance); // Letakkan di PQ (mungkin) }
if(thePQ.size()==0) // Tidak ada vertex di PQ? {
System.out.println(" GRAPH TIDAK TERHUBUNG!"); return;
}
// Hapus lintasan (edge) dengan jarak minimum, dari PQ Edge theEdge = thePQ.removeMin();
int sourceVert = theEdge.srcVert; currentVert = theEdge.destVert;
// Menampilkan lintasan (edge) dari source ke current System.out.print( vertexList[sourceVert].label ); System.out.print( vertexList[currentVert].label ); System.out.print(" ");
} // end while(tidak semua verts di tree) // mst is complete
for(int j=0; j<nVerts; j++) // Hilangkan tanda di vertex-vertex. vertexList[j].isInTree = false;
// --- public void putInPQ(int newVert, int newDist) {
// Apa ada lintasan (edge) lain yang bertujuan sama? int queueIndex = thePQ.find(newVert);
if(queueIndex != -1) // Mendapatkan index lintasan (edge). {
Edge tempEdge = thePQ.peekN(queueIndex); // Mendapatkan lintasan (edge). int oldDist = tempEdge.distance;
if(oldDist > newDist) // Jika lintasan (edge) baru lebih pendek. {
thePQ.removeN(queueIndex); // Hapus lintasan (edge) lama. Edge theEdge = new Edge(currentVert, newVert, newDist); thePQ.insert(theEdge); // Sisipkan lintasan (edge) baru. }
// else tidak ada aksi apa-apa; // tinggalkan vertex lama di sini. } // end if
else // Tidak ada lintasan (edge) dengan vertex tujuan yang sama { // sisipkan yang baru.
Edge theEdge = new Edge(currentVert, newVert, newDist); thePQ.insert(theEdge);
}
} // end putInPQ()
// --- } // end class Graph
Percobaan 8. MSTWApp
package MFS_for_WEIGHTGRAPH; class MSTWApp
{
public static void main(String[] args) {
Graph theGraph = new Graph();
theGraph.addVertex('A'); // 0 (start for mst) theGraph.addVertex('B'); // 1
theGraph.addVertex('C'); // 2 theGraph.addVertex('D'); // 3 theGraph.addVertex('E'); // 4
theGraph.addVertex('F'); // 5 theGraph.addEdge(0, 1, 6); // AB 6 theGraph.addEdge(0, 3, 4); // AD 4 theGraph.addEdge(1, 2, 10); // BC 10 theGraph.addEdge(1, 3, 7); // BD 7 theGraph.addEdge(1, 4, 7); // BE 7 theGraph.addEdge(2, 3, 8); // CD 8 theGraph.addEdge(2, 4, 5); // CE 5 theGraph.addEdge(2, 5, 6); // CF 6 theGraph.addEdge(3, 4, 12); // DE 12 theGraph.addEdge(4, 5, 7); // EF 7
System.out.println("Minimum Spanning Tree : "); theGraph.mstw(); // minimum spanning tree } // end main()
} // end class MSTWApp
/////////////////////////////////////////////////////////////// Percobaan 9. PriorityQ
package MFS_for_WEIGHTGRAPH; class PriorityQ
{
// array dalam keadaan terurut, dari max = 0 hingga min = size-1 private final int SIZE = 20;
private Edge[] queArray; private int size;
public PriorityQ() // constructor {
queArray = new Edge[SIZE]; size = 0;
}
public void insert(Edge item) // Masukkan item dalam keadaan terurut. {
int j;
for(j=0; j<size; j++) // Temukan tempat penyisipan. if( item.distance >= queArray[j].distance )
break;
for(int k=size-1; k>=j; k--) // Gerakkan item ke atas. queArray[k+1] = queArray[k];
queArray[j] = item; // Sisipkan item. size++;
}
public Edge removeMin() // Hapus item minimum. { return queArray[--size]; }
public void removeN(int n) // Hapus item di n {
for(int j=n; j<size-1; j++) // Gerakkan item ke bawah. queArray[j] = queArray[j+1];
size--; }
public Edge peekMin() // Lihat item minimum. { return queArray[size-1]; }
public int size() // Kembalikan jumlah item. { return size; }
public boolean isEmpty() // true jika queue kosong. { return (size==0); }
public Edge peekN(int n) // Lihat item n { return queArray[n]; }
public int find(int findDex) // Temukan item dengan nilai destVert yang dispesifikasi. { for(int j=0; j<size; j++) if(queArray[j].destVert == findDex) return j; return -1; }
} // end class PriorityQ Percobaan 10. MST Vertex
package MFS_for_WEIGHTGRAPH; class Vertex
{
public char label; // label (misal : 'A') public boolean isInTree;
// --- public Vertex(char lab) // constructor
{
label = lab; isInTree = false; }
} // end class Vertex Percobaan 11. Distpar
package SHORTESTPATH_WEIGHTGRAPH; class DistPar // jarak (distance) dan induk (parent). { // item-item tersimpan di array sPath.
public int distance; // jarak dari start ke vertex ini. public int parentVert; // induk (parent) vertex saat ini. public DistPar(int pv, int d) // constructor
{
distance = d; parentVert = pv; }
} // end class DistPar
Percobaan 12. Graph shortestPath
package SHORTESTPATH_WEIGHTGRAPH; class Graph
{
private final int MAX_VERTS = 20; private final int INFINITY = 1000000;
private Vertex vertexList[]; // Daftar vertex-vertex. private int adjMat[][]; // adjacency matrix
private int nVerts; // jumlah vertex saat ini. private int nTree; // jumlah verts di tree. // array untuk data lintasan terpendek // (shortest-path)
private DistPar sPath[];
private int currentVert; // vertex saat ini.
private int startToCurrent; // jarak ke currentVert.
// --- public Graph() // constructor
{
vertexList = new Vertex[MAX_VERTS]; // adjacency matrix
nVerts = 0; nTree = 0;
// menginisialisasi adjacency matrix // ke infinity.
for(int j=0; j<MAX_VERTS; j++) for(int k=0; k<MAX_VERTS; k++) // Lintasan terpendek (shortest path).
adjMat[j][k] = INFINITY; sPath = new DistPar[MAX_VERTS]; } // end constructor
// --- public void addVertex(char lab)
{
vertexList[nVerts++] = new Vertex(lab); }
// --- public void addEdge(int start, int end, int weight) {
adjMat[start][end] = weight; // (berarah) }
// --- // Menemukan semua lintasan terpendek
// (shortest path). public void path() {
int startTree = 0; // mulai dari vertex 0 vertexList[startTree].isInTree = true; nTree = 1; // letakkan di tree // transfer baris-baris (distances) dari // adjMat ke sPath.
for(int j=0; j<nVerts; j++) {
int tempDist = adjMat[startTree][j];
sPath[j] = new DistPar(startTree, tempDist); }
// hingga semua vertex ada di tree. while(nTree < nVerts)
{
// mendapat nilai minimum dari sPath. int indexMin = getMin();
int minDist = sPath[indexMin].distance; if(minDist == INFINITY) // jika semua infinite { // atau ada di tree,
System.out.println
("Simpul (vertex) tidak dapat dicapai! "); break; // sPath selesai.
} else
{ // melakukan pengaturan-ulang currentVert. currentVert = indexMin; // ke vert terdekat. startToCurrent = sPath[indexMin].distance; // jarak minimum dari startTree adalah // ke currentVert, dan startToCurrent. }
// Letakkan vertex saat ini ke tree. vertexList[currentVert].isInTree = true; nTree++;
adjust_sPath(); // perbaharui array sPath[]. } // end while(nTree<nVerts)
displayPaths(); // tampilkan isi sPath[] nTree = 0; // hapus tree.
for(int j=0; j<nVerts; j++) vertexList[j].isInTree = false; } // end path()
// --- public int getMin() // mendapatkan entry dari sPath { // yang memiliki jarak minimum.
int minDist = INFINITY; // asumsikan minimum. int indexMin = 0;
for(int j=1; j<nVerts; j++) // untuk setiap vertex, { // jika ada di tree dan
if( !vertexList[j].isInTree && // lebih kecil dari yang lama. sPath[j].distance < minDist )
{
minDist = sPath[j].distance; indexMin = j; // update minimum }
} // end for
return indexMin; // mengembalikan index minimum } // end getMin()
// --- public void adjust_sPath()
{
// mengatur nilai-nilai dalam array sPath // yang berisi lintasan terpendek. int column = 1; // lompati vertex awal. while(column < nVerts) // melintas kolom. {
// jika kolom vertex ada di tree, lompati. if( vertexList[column].isInTree ) {
column++; continue; }
// hitung jarak dari suatu entry sPath,
// dapatkan lintasan (edge) dari currentVert ke kolom. int currentToFringe = adjMat[currentVert][column]; // tambahkan jarak dari start
int startToFringe = startToCurrent + currentToFringe; // dapatkan jarak (distance) entri sPath saat ini. int sPathDist = sPath[column].distance; // bandingkan jarak (distance) dari // start dengan entri sPath.
if(startToFringe < sPathDist) // jika lebih pendek, { // perbaharui sPath
sPath[column].parentVert = currentVert; sPath[column].distance = startToFringe; }
column++;
} // end while(column < nVerts) } // end adjust_sPath()
// --- public void displayPaths()
{
for(int j=0; j<nVerts; j++) { System.out.print(vertexList[j].label + "="); // B= if(sPath[j].distance == INFINITY) System.out.print("inf"); // inf else System.out.print(sPath[j].distance); // 50
char parent = vertexList[ sPath[j].parentVert ].label; System.out.print("(" + parent + ") "); // (A)
}
System.out.println(""); }
// --- } // end class Graph
Percobaan 13. PathApp
package SHORTESTPATH_WEIGHTGRAPH; class PathApp
{
public static void main(String[] args) {
Graph theGraph = new Graph(); theGraph.addVertex('A'); // 0 (start) theGraph.addVertex('C'); // 2 theGraph.addVertex('B'); // 1 theGraph.addVertex('D'); // 3 theGraph.addVertex('E'); // 4 theGraph.addEdge(0, 1, 50); // AB 50 theGraph.addEdge(0, 3, 80); // AD 80 theGraph.addEdge(1, 2, 60); // BC 60 theGraph.addEdge(1, 3, 90); // BD 90 theGraph.addEdge(2, 4, 40); // CE 40 theGraph.addEdge(3, 2, 20); // DC 20 theGraph.addEdge(3, 4, 70); // DE 70 theGraph.addEdge(4, 1, 50); // EB 50 System.out.println("Shortest paths"); theGraph.path(); // shortest paths
System.out.println(); } // end main() } // end class PathApp
Percobaan 14.Vertex shortestPath
package SHORTESTPATH_WEIGHTGRAPH; class Vertex
{
public char label; // label (misalnya : 'A') public boolean isInTree;
// --- public Vertex(char lab) // constructor
{
label = lab; isInTree = false; }
// --- } // end class Vertex
Percobaan 15. GraphTopo package topologiSorting;
class GraphTopo {
private final int MAX_VERTS = 20; private Vertex vertexList[]; // Daftar vertex private int adjMat[][]; // adjacency matrix private int nVerts; // Jumlah vertex private char sortedArray[];
// --- public GraphTopo() // constructor
{
vertexList = new Vertex[MAX_VERTS]; // adjacency matrix
adjMat = new int[MAX_VERTS][MAX_VERTS]; nVerts = 0;
for(int k=0; k<MAX_VERTS; k++) // matrix ke 0 adjMat[j][k] = 0;
sortedArray = new char[MAX_VERTS]; // Label vert terurut. } // end constructor
// --- public void addVertex(char lab)
{
vertexList[nVerts++] = new Vertex(lab); }
// --- public void addEdge(int start, int end)
{
adjMat[start][end] = 1; }
// --- public void displayVertex(int v)
{
System.out.print(vertexList[v].label); }
// --- public void topo() // topological sort
{
int orig_nVerts = nVerts; // Mengingat berapa verts while(nVerts > 0) // sementara vertex ada,
{
// Mendapat vertex tanpa successors, atau -1 int currentVertex = noSuccessors();
if(currentVertex == -1) // harus merupakan siklus {
System.out.println("ERROR: Graph has cycles"); return;
}
// Menyisipkan label vertex label dalam array terurut (start hingga end)
sortedArray[nVerts-1] = vertexList[currentVertex].label;
deleteVertex(currentVertex); // delete vertex } // end while
// vertices all gone; display sortedArray
for(int j=0; j<orig_nVerts; j++)
System.out.println( sortedArray[j] ); System.out.println("\n");
} // end topo // ---
public int noSuccessors() // Mengembalikan vert tanpa successors { // (atau -1 jika verts tidak ada)
boolean isEdge; // Lintasan (edge) dari ke to column dalam adjMat for(int row=0; row<nVerts; row++) // untuk setiap vertex,
{
isEdge = false; // periksa lintasan (edge) for(int col=0; col<nVerts; col++) {
if( adjMat[row][col] > 0 ) // Jika lintasan (edge) ke { // yang lain,
isEdge = true; break; // vertex ini } // memiliki successor, } // coba yang lain.
if( !isEdge ) // Jika tidak ada lintasan (edge) return row; // Tidak ada successor
}
return -1; // Tidak ada vertex } // end noSuccessors() // ---
public void deleteVertex(int delVert) {
if(delVert != nVerts-1) // Jika bukan vertex terakhir, { // hapus dari vertexList
for(int j=delVert; j<nVerts-1; j++) vertexList[j] = vertexList[j+1]; // hapus row dari adjMat
for(int row=delVert; row<nVerts-1; row++) moveRowUp(row, nVerts);
// hapus col dari adjMat
for(int col=delVert; col<nVerts-1; col++) moveColLeft(col, nVerts-1);
}
nVerts--; // Kurangi vertex } // end deleteVertex
// ---
private void moveRowUp(int row, int length) {
for(int col=0; col<length; col++) adjMat[row][col] = adjMat[row+1][col]; }
// ---
private void moveColLeft(int col, int length) {
for(int row=0; row<length; row++) adjMat[row][col] = adjMat[row][col+1]; }
// --- } // end class Graph
Percobaan 16. TestGraphTopo package topologiSorting; public class TestGraphTopo {
public static void main(String[] args) {
GraphTopo theGraph = new GraphTopo(); theGraph.addVertex('A'); // 0 theGraph.addVertex('B'); // 1 theGraph.addVertex('C'); // 2 theGraph.addVertex('D'); // 3 theGraph.addVertex('E'); // 4 theGraph.addVertex('F'); // 5 theGraph.addVertex('G'); // 6 theGraph.addVertex('H'); // 7 theGraph.addEdge(0, 3); // AD theGraph.addEdge(0, 4); // AE theGraph.addEdge(1, 4); // BE theGraph.addEdge(2, 5); // CF theGraph.addEdge(3, 6); // DG theGraph.addEdge(4, 6); // EG theGraph.addEdge(5, 7); // FH theGraph.addEdge(6, 7); // GH
theGraph.topo(); // Lakukan pengurutan. } // end main()
Percobaan 17. VertexTopo package topologiSorting; class Vertex
{
public char label; // Label (misal. 'A') public boolean wasVisited;
// ---
public Vertex(char lab) // Constructor. {
label = lab; wasVisited = false; }
// --- } // end class Vertex
5. Tugas Praktikum
Buat Kesimpulan dengan deskripsi tentang penggunaan struktur data graph dari beberapa percobaan diatas