added dijkstra's algorithm in java

graph-algos/Dijkstra/README.md

@@ -0,0 +1,9 @@
+
+## Dijkstra's Algorithm
+
+Dijkstra's algorithm is an algorithm for finding the shortest paths between nodes in a graph, which may represent, for example, road networks.
+It was conceived by computer scientist Edsger W. Dijkstra in 1956 and published three years later.
+
+For a given source node in the graph, the algorithm finds the shortest path between that node and every other.It can also be used for finding the shortest paths from a single node to a single destination node by stopping the algorithm once the shortest path to the destination node has been determined. <br>For example, if the nodes of the graph represent cities and edge path costs represent driving distances between pairs of cities connected by a direct road, Dijkstra's algorithm can be used to find the shortest route between one city and all other cities.
+
+[visualize Dijkstra's Algorithm](https://www.cs.usfca.edu/~galles/visualization/Dijkstra.html)

graph-algos/Dijkstra/dijkstras.java

@@ -0,0 +1,63 @@
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+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[], int n)
+    {
+        System.out.println("Vertex   Distance from Source");
+        for (int i = 0; i < V; i++)
+            System.out.println(i+"              "+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, V);
+    }
+    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);
+    }
+}