graphs | new question added

Author: arorarahul

README.md

@@ -186,13 +186,28 @@ it gets converted to i-1,j-1 or we take min or max of i,j-1 and i-1,j
 ## Graphs
 
 - Most of the graph questions revolves around finding the adjacent nodes and doing operations on it. Finding adjacent nodes is easy as you can get it from the matrix easily by seeing if the value corresponding to that vertex and some i is 1 and that it has to be unvisited. So basically we either do DFS or BFS.
-- When path between two vertices is to be found, they need not be connected directly
+- When path between two vertices is to be found, they need not be connected directly. There may be some vertices/ nodes in between.
 
-## Advanced algos
+## Advanced data
 
 - Use KMP to find if a pattern exists in a text or not
 - For Graphs, Topological sort is possible only on directed acyclic graphs (one with no cycles). Useful when one task is dependent on other.
 
+## Advanced data structures
+
+- Disjoint sets: If two nodes are connected or belong to the same category they will be a part of the same set. Disjoint sets can be represented in two ways.
+	1) Linked list
+	2) Trees
+
+There are three kind of operations that can be applied on such sets.
+	1) Find
+	2) Union
+	3) Create
+
+Implementation using trees is better as we can apply union by rank and path compression to make sure find happens in logn or constant time, create anyway happens in constant time only.
+In case of linked list find takes O(n) time and union also takes O(n) time and create takes O(1) time
+
+
 # Topic0: Programming Questions
 
 ## Note:
@@ -427,6 +442,7 @@ it gets converted to i-1,j-1 or we take min or max of i,j-1 and i-1,j
 - [Implement a graph using adjacency matrix and do BFT in a different way for custom value of nodes](/graphs/question2.c)
 - [Write a program to do topological sort in a graph](/graphs/question3.c)
 - [Find if there is a path between two vertices Vi and Vj in a directed graph](/graphs/question4.c)
+- [Given an undirected graph, find if it has a cycle or not](/graphs/question5.c)
 
 
 ### Pattern Matching

graphs/question5.c

@@ -0,0 +1,137 @@
+/*
+Given an undirected graph, find if it has a cycle or not
+
+METHOD1:
+We can do DFS and if any node at any given point does not have any where to go as per DFS, i.e visited of all 
+its neighbours are 1, then it will have a cycle
+
+Time complexity: O(V+E) //in worst case we will end up visited every node twice
+
+METHOD2:
+We can use union and find algorithm
+*/
+
+//METHOD1
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#define MAX 100
+
+int queue[MAX];
+int rear = -1, front = 0;
+
+int queueElementCount = 0;
+
+int visited[MAX];
+
+struct AdjListNode{
+	int data;
+	struct AdjListNode *next;
+};
+
+struct AdjList{
+	struct AdjListNode *head;
+};
+
+struct Graph{
+	int vertices, edges;
+	struct AdjList *map;
+} *newGraph;
+
+int dequeue(){
+	queueElementCount--;
+	return queue[front++];
+}
+
+void enqueue(int data){
+	queueElementCount++;
+	queue[++rear] = data;
+}
+
+bool isQueueEmpty(){
+	return queueElementCount == 0;
+}
+
+struct AdjListNode *createNode(int data){
+	struct AdjListNode *temp = (struct AdjListNode *)malloc(sizeof(struct AdjListNode));
+	temp->data = data;
+	temp->next = NULL;
+	return temp;
+}
+
+void addEdge(int start, int end){
+	struct AdjListNode *newNode = createNode(end);
+	if(newGraph->map[start].head){
+		newNode->next = newGraph->map[start].head;
+		newGraph->map[start].head = newNode;
+	}else{
+		newGraph->map[start].head = newNode;
+	}
+	newNode = createNode(start);
+	if(newGraph->map[end].head){
+		newNode->next = newGraph->map[end].head;
+		newGraph->map[end].head = newNode;
+	}else{
+		newGraph->map[end].head = newNode;
+	}
+}
+
+void displayAdjList(){
+	int i;
+
+	for(i=0;i<newGraph->vertices;i++){
+		struct AdjListNode *temp = newGraph->map[i].head;
+		printf("%d --> ", i);
+		while(temp){
+			printf("%d --> ", temp->data);
+			temp = temp->next;
+		}
+		printf("\n");
+	}
+}
+
+int dfs(int index, int parent){
+	visited[index] = 1;
+
+	struct AdjListNode *temp = newGraph->map[index].head;
+	while(temp){
+		if(visited[temp->data] != 1){
+			parent = index;
+			dfs(temp->data, parent);
+		}else if(visited[temp->data] == 1 && temp->data != parent){
+			return 1;
+		}
+		temp = temp->next;
+	} 
+	return 0;
+}
+
+int isCyclePresent(){
+	return dfs(0,-1);
+}	
+
+int main(){
+
+	int vertices = 5;
+
+	newGraph = (struct Graph *)malloc(sizeof(struct Graph));
+	newGraph->vertices = vertices;
+	newGraph->map = (struct AdjList *)calloc(sizeof(struct AdjList),vertices);
+
+	addEdge(0,1);
+	addEdge(1,4);
+	addEdge(0,2);
+	addEdge(0,3);
+	addEdge(2,3);
+
+	displayAdjList();
+
+	if(isCyclePresent()){
+		printf("Graph contains a cycle\n");
+	}else{
+		printf("Graph does not contain a cycle\n");
+	}	
+
+	return 0;
+}
+

nextquestions.md

@@ -104,4 +104,6 @@ TODO:
 - trees question20 all methods (3) to be done GFG or R
 - geeks for geeks for DP
 - Graph topological sort method2 and matrix implementation of topo
+- Write a program to detect a cycle in a graph (question5) method2
+- breadth and depth first traversal in a tree