Algorithm

Dijkstra.java

@@ -0,0 +1,70 @@
+import java.io.*;
+import java.lang.*;
+import java.util.*;
+
+class ShortestPath {
+    static final int V = 9;
+    int minDistance(int dist[], Boolean sptSet[])
+    {
+        int min = Integer.MAX_VALUE, min_index = -1;
+
+        for (int v = 0; v < V; v++)
+            if (sptSet[v] == false && dist[v] <= min) {
+                min = dist[v];
+                min_index = v;
+            }
+
+        return min_index;
+    }
+
+    void printSolution(int dist[])
+    {
+        System.out.println(
+            "Vertex \t\t Distance from Source");
+        for (int i = 0; i < V; i++)
+            System.out.println(i + " \t\t " + dist[i]);
+    }
+    void dijkstra(int graph[][], int src)
+    {
+        int dist[] = new int[V];
+        Boolean sptSet[] = new Boolean[V];
+
+        for (int i = 0; i < V; i++) {
+            dist[i] = Integer.MAX_VALUE;
+            sptSet[i] = false;
+        }
+
+        dist[src] = 0;
+
+        for (int count = 0; count < V - 1; count++) {
+            int u = minDistance(dist, sptSet);
+
+            sptSet[u] = true;
+
+            for (int v = 0; v < V; v++)
+                if (!sptSet[v] && graph[u][v] != 0
+                    && dist[u] != Integer.MAX_VALUE
+                    && dist[u] + graph[u][v] < dist[v])
+                    dist[v] = dist[u] + graph[u][v];
+        }
+
+        printSolution(dist);
+    }
+
+    public static void main(String[] args)
+    {
+        int graph[][]
+            = new int[][] { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },
+                            { 4, 0, 8, 0, 0, 0, 0, 11, 0 },
+                            { 0, 8, 0, 7, 0, 4, 0, 0, 2 },
+                            { 0, 0, 7, 0, 9, 14, 0, 0, 0 },
+                            { 0, 0, 0, 9, 0, 10, 0, 0, 0 },
+                            { 0, 0, 4, 14, 10, 0, 2, 0, 0 },
+                            { 0, 0, 0, 0, 0, 2, 0, 1, 6 },
+                            { 8, 11, 0, 0, 0, 0, 1, 0, 7 },
+                            { 0, 0, 2, 0, 0, 0, 6, 7, 0 } };
+        ShortestPath t = new ShortestPath();
+
+        t.dijkstra(graph, 0);
+    }
+}

Prims.java

@@ -0,0 +1,80 @@
+import java.io.*;
+import java.lang.*;
+import java.util.*;
+
+class Prims {
+
+    private static final int V = 5;
+
+    int minKey(int key[], Boolean mstSet[])
+    {
+        int min = Integer.MAX_VALUE, min_index = -1;
+
+        for (int v = 0; v < V; v++)
+            if (mstSet[v] == false && key[v] < min) {
+                min = key[v];
+                min_index = v;
+            }
+
+        return min_index;
+    }
+    void printMST(int parent[], int graph[][])
+    {
+        System.out.println("Edge \tWeight");
+        for (int i = 1; i < V; i++)
+            System.out.println(parent[i] + " - " + i + "\t"
+                               + graph[i][parent[i]]);
+    }
+
+    void primMST(int graph[][])
+    {
+        int parent[] = new int[V];
+        int key[] = new int[V];
+
+        Boolean mstSet[] = new Boolean[V];
+
+        // Initialize all keys as INFINITE
+        for (int i = 0; i < V; i++) {
+            key[i] = Integer.MAX_VALUE;
+            mstSet[i] = false;
+        }
+
+        key[0] = 0; 
+        parent[0] = -1; 
+
+        for (int count = 0; count < V - 1; count++) {
+            int u = minKey(key, mstSet);
+
+            mstSet[u] = true;
+
+            for (int v = 0; v < V; v++)
+                if (graph[u][v] != 0 && mstSet[v] == false
+                    && graph[u][v] < key[v]) {
+                    parent[v] = u;
+                    key[v] = graph[u][v];
+                }
+        }
+
+        printMST(parent, graph);
+    }
+
+    public static void main(String[] args)
+    {
+        /* Let us create the following graph
+        2 3
+        (0)--(1)--(2)
+        | / \ |
+        6| 8/ \5 |7
+        | /     \ |
+        (3)-------(4)
+            9         */
+        MST t = new MST();
+        int graph[][] = new int[][] { { 0, 2, 0, 6, 0 },
+                                      { 2, 0, 3, 8, 5 },
+                                      { 0, 3, 0, 0, 7 },
+                                      { 6, 8, 0, 0, 9 },
+                                      { 0, 5, 7, 9, 0 } };
+
+        t.primMST(graph);
+    }
+}