Merge pull request #88 from saty-a/main

Add: algoritms in java

Java/Algorithms/Dijkstra.java

@@ -0,0 +1,186 @@
+// Java Program to Implement Dijkstra's Algorithm
+// Using Priority Queue
+
+// Importing utility classes
+import java.util.*;
+
+// Main class DPQ
+public class Dijkstra {
+
+	// Member variables of this class
+	private int dist[];
+	private Set<Integer> settled;
+	private PriorityQueue<Node> pq;
+	// Number of vertices
+	private int V;
+	List<List<Node> > adj;
+
+	// Constructor of this class
+	public Dijkstra(int V)
+	{
+
+		// This keyword refers to current object itself
+		this.V = V;
+		dist = new int[V];
+		settled = new HashSet<Integer>();
+		pq = new PriorityQueue<Node>(V, new Node());
+	}
+
+	// Method 1
+	// Dijkstra's Algorithm
+	public void dijkstra(List<List<Node> > adj, int src)
+	{
+		this.adj = adj;
+
+		for (int i = 0; i < V; i++)
+			dist[i] = Integer.MAX_VALUE;
+
+		// Add source node to the priority queue
+		pq.add(new Node(src, 0));
+
+		// Distance to the source is 0
+		dist[src] = 0;
+
+		while (settled.size() != V) {
+
+			// Terminating condition check when
+			// the priority queue is empty, return
+			if (pq.isEmpty())
+				return;
+
+			// Removing the minimum distance node
+			// from the priority queue
+			int u = pq.remove().node;
+
+			// Adding the node whose distance is
+			// finalized
+			if (settled.contains(u))
+
+				// Continue keyword skips execution for
+				// following check
+				continue;
+
+			// We don't have to call e_Neighbors(u)
+			// if u is already present in the settled set.
+			settled.add(u);
+
+			e_Neighbours(u);
+		}
+	}
+
+	// Method 2
+	// To process all the neighbours
+	// of the passed node
+	private void e_Neighbours(int u)
+	{
+
+		int edgeDistance = -1;
+		int newDistance = -1;
+
+		// All the neighbors of v
+		for (int i = 0; i < adj.get(u).size(); i++) {
+			Node v = adj.get(u).get(i);
+
+			// If current node hasn't already been processed
+			if (!settled.contains(v.node)) {
+				edgeDistance = v.cost;
+				newDistance = dist[u] + edgeDistance;
+
+				// If new distance is cheaper in cost
+				if (newDistance < dist[v.node])
+					dist[v.node] = newDistance;
+
+				// Add the current node to the queue
+				pq.add(new Node(v.node, dist[v.node]));
+			}
+		}
+	}
+
+	// Main driver method
+	public static void main(String arg[])
+	{
+
+		int V = 5;
+		int source = 0;
+
+		// Adjacency list representation of the
+		// connected edges by declaring List class object
+		// Declaring object of type List<Node>
+		List<List<Node> > adj
+			= new ArrayList<List<Node> >();
+
+		// Initialize list for every node
+		for (int i = 0; i < V; i++) {
+			List<Node> item = new ArrayList<Node>();
+			adj.add(item);
+		}
+
+		// Inputs for the GFG(dpq) graph
+		adj.get(0).add(new Node(1, 9));
+		adj.get(0).add(new Node(2, 6));
+		adj.get(0).add(new Node(3, 5));
+		adj.get(0).add(new Node(4, 3));
+
+		adj.get(2).add(new Node(1, 2));
+		adj.get(2).add(new Node(3, 4));
+
+		// Calculating the single source shortest path
+		Dijkstra dpq = new Dijkstra(V);
+		dpq.dijkstra(adj, source);
+
+		// Printing the shortest path to all the nodes
+		// from the source node
+		System.out.println("The shorted path from node :");
+
+		for (int i = 0; i < dpq.dist.length; i++)
+			System.out.println(source + " to " + i + " is "
+							+ dpq.dist[i]);
+	}
+}
+
+// Class 2
+// Helper class implementing Comparator interface
+// Representing a node in the graph
+class Node implements Comparator<Node> {
+
+	// Member variables of this class
+	public int node;
+	public int cost;
+
+	// Constructors of this class
+
+	// Constructor 1
+	public Node() {}
+
+	// Constructor 2
+	public Node(int node, int cost)
+	{
+
+		// This keyword refers to current instance itself
+		this.node = node;
+		this.cost = cost;
+	}
+
+	// Method 1
+	@Override public int compare(Node node1, Node node2)
+	{
+
+		if (node1.cost < node2.cost)
+			return -1;
+
+		if (node1.cost > node2.cost)
+			return 1;
+
+		return 0;
+	}
+}
+
+/// The Output will be
+/*
+The shorted path from node :
+0 to 0 is 0
+0 to 1 is 8
+0 to 2 is 6
+0 to 3 is 5
+0 to 4 is 3
+ */

Java/Algorithms/KruskalsMST.java

@@ -0,0 +1,143 @@
+// Java program for Kruskal's algorithm 
+
+import java.util.ArrayList; 
+import java.util.Comparator; 
+import java.util.List; 
+
+public class KruskalsMST { 
+
+	// Defines edge structure 
+	static class Edge { 
+		int src, dest, weight; 
+
+		public Edge(int src, int dest, int weight) 
+		{ 
+			this.src = src; 
+			this.dest = dest; 
+			this.weight = weight; 
+		} 
+	} 
+
+	// Defines subset element structure 
+	static class Subset { 
+		int parent, rank; 
+
+		public Subset(int parent, int rank) 
+		{ 
+			this.parent = parent; 
+			this.rank = rank; 
+		} 
+	} 
+
+	// Starting point of program execution 
+	public static void main(String[] args) 
+	{ 
+		int V = 4; 
+		List<Edge> graphEdges = new ArrayList<Edge>( 
+			List.of(new Edge(0, 1, 10), new Edge(0, 2, 6), 
+					new Edge(0, 3, 5), new Edge(1, 3, 15), 
+					new Edge(2, 3, 4))); 
+
+		// Sort the edges in non-decreasing order 
+		// (increasing with repetition allowed) 
+		graphEdges.sort(new Comparator<Edge>() { 
+			@Override public int compare(Edge o1, Edge o2) 
+			{ 
+				return o1.weight - o2.weight; 
+			} 
+		}); 
+
+		kruskals(V, graphEdges); 
+	} 
+
+	// Function to find the MST 
+	private static void kruskals(int V, List<Edge> edges) 
+	{ 
+		int j = 0; 
+		int noOfEdges = 0; 
+
+		// Allocate memory for creating V subsets 
+		Subset subsets[] = new Subset[V]; 
+
+		// Allocate memory for results 
+		Edge results[] = new Edge[V]; 
+
+		// Create V subsets with single elements 
+		for (int i = 0; i < V; i++) { 
+			subsets[i] = new Subset(i, 0); 
+		} 
+
+		// Number of edges to be taken is equal to V-1 
+		while (noOfEdges < V - 1) { 
+
+			// Pick the smallest edge. And increment 
+			// the index for next iteration 
+			Edge nextEdge = edges.get(j); 
+			int x = findRoot(subsets, nextEdge.src); 
+			int y = findRoot(subsets, nextEdge.dest); 
+
+			// If including this edge doesn't cause cycle, 
+			// include it in result and increment the index 
+			// of result for next edge 
+			if (x != y) { 
+				results[noOfEdges] = nextEdge; 
+				union(subsets, x, y); 
+				noOfEdges++; 
+			} 
+
+			j++; 
+		} 
+
+		// Print the contents of result[] to display the 
+		// built MST 
+		System.out.println( 
+			"Following are the edges of the constructed MST:"); 
+		int minCost = 0; 
+		for (int i = 0; i < noOfEdges; i++) { 
+			System.out.println(results[i].src + " -- "
+							+ results[i].dest + " == "
+							+ results[i].weight); 
+			minCost += results[i].weight; 
+		} 
+		System.out.println("Total cost of MST: " + minCost); 
+	} 
+
+	// Function to unite two disjoint sets 
+	private static void union(Subset[] subsets, int x, 
+							int y) 
+	{ 
+		int rootX = findRoot(subsets, x); 
+		int rootY = findRoot(subsets, y); 
+
+		if (subsets[rootY].rank < subsets[rootX].rank) { 
+			subsets[rootY].parent = rootX; 
+		} 
+		else if (subsets[rootX].rank 
+				< subsets[rootY].rank) { 
+			subsets[rootX].parent = rootY; 
+		} 
+		else { 
+			subsets[rootY].parent = rootX; 
+			subsets[rootX].rank++; 
+		} 
+	} 
+
+	// Function to find parent of a set 
+	private static int findRoot(Subset[] subsets, int i) 
+	{ 
+		if (subsets[i].parent == i) 
+			return subsets[i].parent; 
+
+		subsets[i].parent 
+			= findRoot(subsets, subsets[i].parent); 
+		return subsets[i].parent; 
+	} 
+} 
+
+// Output will be like :
+/*
+2 -- 3 == 4
+0 -- 3 == 5
+0 -- 1 == 10
+Minimum Cost Spanning Tree: 19
+ */