Graph Algorithms Added

GraphProblem/GraphBFS.java

@@ -0,0 +1,84 @@
+package GraphProblem;
+
+//Java program to print BFS traversal from a given source vertex. 
+//BFS(int s) traverses vertices reachable from s. 
+import java.io.*; 
+import java.util.*; 
+
+//This class represents a directed graph using adjacency list 
+//representation 
+public class GraphBFS
+{ 
+	private int V; // No. of vertices 
+	private LinkedList<Integer> adj[]; //Adjacency Lists 
+
+	// Constructor 
+	GraphBFS(int v) 
+	{ 
+		V = v; 
+		adj = new LinkedList[v]; 
+		for (int i=0; i<v; ++i) 
+			adj[i] = new LinkedList(); 
+	} 
+
+	// Function to add an edge into the graph 
+	void addEdge(int v,int w) 
+	{ 
+		adj[v].add(w); 
+	} 
+
+	// prints BFS traversal from a given source s 
+	void BFS(int s) 
+	{ 
+		// Mark all the vertices as not visited(By default 
+		// set as false) 
+		boolean visited[] = new boolean[V]; 
+
+		// Create a queue for BFS 
+		LinkedList<Integer> queue = new LinkedList<Integer>(); 
+
+		// Mark the current node as visited and enqueue it 
+		visited[s]=true; 
+		queue.add(s); 
+
+		while (queue.size() != 0) 
+		{ 
+			// Dequeue a vertex from queue and print it 
+			s = queue.poll(); 
+			System.out.print(s+" "); 
+
+			// Get all adjacent vertices of the dequeued vertex s 
+			// If a adjacent has not been visited, then mark it 
+			// visited and enqueue it 
+			Iterator<Integer> i = adj[s].listIterator(); 
+			while (i.hasNext()) 
+			{ 
+				int n = i.next(); 
+				if (!visited[n]) 
+				{ 
+					visited[n] = true; 
+					queue.add(n); 
+				} 
+			} 
+		} 
+	} 
+
+	// Driver method to 
+	public static void main(String args[]) 
+	{ 
+		GraphBFS g = new GraphBFS(4); 
+
+		g.addEdge(0, 1); 
+		g.addEdge(0, 2); 
+		g.addEdge(1, 2); 
+		g.addEdge(2, 0); 
+		g.addEdge(2, 3); 
+		g.addEdge(3, 3); 
+
+		System.out.println("Following is Breadth First Traversal "+ 
+						"(starting from vertex 2)"); 
+
+		g.BFS(2); 
+	} 
+} 
+//This code is contributed by Anilabha Baral

GraphProblem/GraphBellman.java

@@ -0,0 +1,136 @@
+package GraphProblem;
+
+
+//A Java program for Bellman-Ford's single source shortest path 
+//algorithm. 
+import java.util.*; 
+import java.lang.*; 
+import java.io.*; 
+
+//A class to represent a connected, directed and weighted graph 
+class GraphBellman { 
+	// A class to represent a weighted edge in graph 
+	class Edge { 
+		int src, dest, weight; 
+		Edge() 
+		{ 
+			src = dest = weight = 0; 
+		} 
+	}; 
+
+	int V, E; 
+	Edge edge[]; 
+
+	// Creates a graph with V vertices and E edges 
+	GraphBellman(int v, int e) 
+	{ 
+		V = v; 
+		E = e; 
+		edge = new Edge[e]; 
+		for (int i = 0; i < e; ++i) 
+			edge[i] = new Edge(); 
+	} 
+
+	// The main function that finds shortest distances from src 
+	// to all other vertices using Bellman-Ford algorithm. The 
+	// function also detects negative weight cycle 
+	void BellmanFord(GraphBellman graph, int src) 
+	{ 
+		int V = graph.V, E = graph.E; 
+		int dist[] = new int[V]; 
+
+		// Step 1: Initialize distances from src to all other 
+		// vertices as INFINITE 
+		for (int i = 0; i < V; ++i) 
+			dist[i] = Integer.MAX_VALUE; 
+		dist[src] = 0; 
+
+		// Step 2: Relax all edges |V| - 1 times. A simple 
+		// shortest path from src to any other vertex can 
+		// have at-most |V| - 1 edges 
+		for (int i = 1; i < V; ++i) { 
+			for (int j = 0; j < E; ++j) { 
+				int u = graph.edge[j].src; 
+				int v = graph.edge[j].dest; 
+				int weight = graph.edge[j].weight; 
+				if (dist[u] != Integer.MAX_VALUE && dist[u] + weight < dist[v]) 
+					dist[v] = dist[u] + weight; 
+			} 
+		} 
+
+		// Step 3: check for negative-weight cycles. The above 
+		// step guarantees shortest distances if graph doesn't 
+		// contain negative weight cycle. If we get a shorter 
+		// path, then there is a cycle. 
+		for (int j = 0; j < E; ++j) { 
+			int u = graph.edge[j].src; 
+			int v = graph.edge[j].dest; 
+			int weight = graph.edge[j].weight; 
+			if (dist[u] != Integer.MAX_VALUE && dist[u] + weight < dist[v]) { 
+				System.out.println("Graph contains negative weight cycle"); 
+				return; 
+			} 
+		} 
+		printArr(dist, V); 
+	} 
+
+	// A utility function used to print the solution 
+	void printArr(int dist[], int V) 
+	{ 
+		System.out.println("Vertex Distance from Source"); 
+		for (int i = 0; i < V; ++i) 
+			System.out.println(i + "\t\t" + dist[i]); 
+	} 
+
+	// Driver method to test above function 
+	public static void main(String[] args) 
+	{ 
+		int V = 5; // Number of vertices in graph 
+		int E = 8; // Number of edges in graph 
+
+		GraphBellman graph = new GraphBellman(V, E); 
+
+		// add edge 0-1 (or A-B in above figure) 
+		graph.edge[0].src = 0; 
+		graph.edge[0].dest = 1; 
+		graph.edge[0].weight = -1; 
+
+		// add edge 0-2 (or A-C in above figure) 
+		graph.edge[1].src = 0; 
+		graph.edge[1].dest = 2; 
+		graph.edge[1].weight = 4; 
+
+		// add edge 1-2 (or B-C in above figure) 
+		graph.edge[2].src = 1; 
+		graph.edge[2].dest = 2; 
+		graph.edge[2].weight = 3; 
+
+		// add edge 1-3 (or B-D in above figure) 
+		graph.edge[3].src = 1; 
+		graph.edge[3].dest = 3; 
+		graph.edge[3].weight = 2; 
+
+		// add edge 1-4 (or A-E in above figure) 
+		graph.edge[4].src = 1; 
+		graph.edge[4].dest = 4; 
+		graph.edge[4].weight = 2; 
+
+		// add edge 3-2 (or D-C in above figure) 
+		graph.edge[5].src = 3; 
+		graph.edge[5].dest = 2; 
+		graph.edge[5].weight = 5; 
+
+		// add edge 3-1 (or D-B in above figure) 
+		graph.edge[6].src = 3; 
+		graph.edge[6].dest = 1; 
+		graph.edge[6].weight = 1; 
+
+		// add edge 4-3 (or E-D in above figure) 
+		graph.edge[7].src = 4; 
+		graph.edge[7].dest = 3; 
+		graph.edge[7].weight = -3; 
+
+		graph.BellmanFord(graph, 0); 
+	} 
+} 
+//This code is contributed by Anilabha Baral.

GraphProblem/GraphDFS.java

@@ -0,0 +1,80 @@
+package GraphProblem;
+
+
+
+//Java program to print DFS traversal from a given given graph 
+import java.io.*; 
+import java.util.*; 
+
+//This class represents a directed graph using adjacency list 
+//representation 
+public class GraphDFS 
+{ 
+	private int V; // No. of vertices 
+
+	// Array of lists for Adjacency List Representation 
+	private LinkedList<Integer> adj[]; 
+
+	// Constructor 
+	GraphDFS(int v) 
+	{ 
+		V = v; 
+		adj = new LinkedList[v]; 
+		for (int i=0; i<v; ++i) 
+			adj[i] = new LinkedList(); 
+	} 
+
+	//Function to add an edge into the graph 
+	void addEdge(int v, int w) 
+	{ 
+		adj[v].add(w); // Add w to v's list. 
+	} 
+
+	// A function used by DFS 
+	void DFSUtil(int v,boolean visited[]) 
+	{ 
+		// Mark the current node as visited and print it 
+		visited[v] = true; 
+		System.out.print(v+" "); 
+
+		// Recur for all the vertices adjacent to this vertex 
+		Iterator<Integer> i = adj[v].listIterator(); 
+		while (i.hasNext()) 
+		{ 
+			int n = i.next(); 
+			if (!visited[n]) 
+				DFSUtil(n, visited); 
+		} 
+	} 
+
+	// The function to do DFS traversal. It uses recursive DFSUtil() 
+	void DFS(int v) 
+	{ 
+		// Mark all the vertices as not visited(set as 
+		// false by default in java) 
+		boolean visited[] = new boolean[V]; 
+
+		// Call the recursive helper function to print DFS traversal 
+		DFSUtil(v, visited); 
+	} 
+
+	public static void main(String args[]) 
+	{ 
+		GraphDFS g = new GraphDFS(4); 
+
+		g.addEdge(0, 1); 
+		g.addEdge(0, 2); 
+		g.addEdge(1, 2); 
+		g.addEdge(2, 0); 
+		g.addEdge(2, 3); 
+		g.addEdge(3, 3); 
+
+		System.out.println("Following is Depth First Traversal "+ 
+						"(starting from vertex 2)"); 
+
+		g.DFS(2); 
+	} 
+} 
+//This code is contributed by Anilabha Baral
+
+