Adjacency list is reachable

Data Structures/Graph/Undirected Graph/UndirectedGraphAdjacenyList.cpp

@@ -0,0 +1,31 @@
+#include<iostream>
+#include<list>
+#include<vector>
+#include<iterator>
+#define Max 10
+using namespace std;
+list<int> g[Max];
+void addEdge(int u,int v){
+	g[u].push_back(v);
+	g[v].push_back(u);
+
+}
+
+void print(){
+	list<int>::iterator ptr;
+	for(int i=1;i<Max;i++){
+		cout<<i<<"->";
+		for(ptr=g[i].begin();ptr!=g[i].end();ptr++){
+			cout<<*ptr<<" ";
+		}
+		cout<<endl;
+	}
+}
+int main(){
+	addEdge(1,2);
+	addEdge(2,6);
+	addEdge(3,5);
+	addEdge(5,6);
+	print();
+	return 0;
+}

Data Structures/Graph/Undirected Graph/UndirectedGraphMatrix.cpp

@@ -0,0 +1,36 @@
+#include<iostream>
+using namespace std;
+#define Max 10
+int graph[Max][Max];
+void addEdge(int u,int v){
+	graph[u][v]=1;
+	graph[v][u]=1;
+}
+
+void prints(){
+	cout<<"   ";
+	for(int j=1;j<Max;j++){
+			cout<<j<<" ";
+		}
+		cout<<endl;
+	for(int i=1;i<Max;i++){
+		cout<<i<<"  ";
+		for(int j=1;j<Max;j++){
+			cout<<graph[i][j]<<" ";
+		}
+		cout<<endl;
+	}
+}
+int main(){
+
+
+	addEdge(1,2);
+    addEdge(3,2);
+    addEdge(3,4);
+    addEdge(4,2);
+    addEdge(4,5);
+    addEdge(5,2);
+    addEdge(5,1);
+    prints();
+	return 0;
+}

Graph Algorithms/AdjacencyList_Indegree_out degree.cpp

@@ -0,0 +1,77 @@
+#include<iostream>
+#include<vector>
+#include<queue>
+#include<list>
+#include<stack>
+#define Max 10
+using namespace std;
+
+class Graph{
+	list<int> adjlist[Max];
+
+	public:
+	void addEdge(int u,int v){
+		adjlist[u].push_back(v);
+	}
+	void printGraph(){
+		list<int>::iterator it;
+
+		for(int i=0;i<Max;i++){
+			cout<<i<<"->";
+			for(it=adjlist[i].begin();it!=adjlist[i].end();++it){
+				cout<<*it<<"-";
+			}
+			cout<<"/\n";
+		}
+		cout<<"\n\n";
+	}
+
+	void outDegree(){
+		list<int>::iterator it;
+		int outdegree[Max]={0};
+		for(int i=0;i<Max;++i){
+			for(it=adjlist[i].begin();it!=adjlist[i].end();++it){
+				outdegree[i]++;
+			}
+		}
+		cout<<"Out degree"<<endl;
+		for(int i=1;i<Max;i++){
+			cout<<i<<":"<<outdegree[i]<<endl;
+		}
+		cout<<"\n\n";
+	}
+	void inDegree(){
+		list<int>::iterator it;
+		int indegree[Max]={0};
+		for(int i=0;i<Max;++i){
+			for(it=adjlist[i].begin();it!=adjlist[i].end();++it){
+				indegree[*it]++;
+			}
+		}
+		cout<<"In degree"<<endl;
+		for(int i=1;i<Max;i++){
+			cout<<i<<":"<<indegree[i]<<endl;
+		}
+		cout<<"\n\n";
+	}
+
+};
+
+int main(){
+	Graph g;
+	g.addEdge(1,2);
+	g.addEdge(3,1);
+	g.addEdge(2,3);
+	g.addEdge(3,4);
+	g.addEdge(4,5);
+	g.addEdge(5,6);
+	g.addEdge(6,7);
+	g.addEdge(7,8);
+	g.addEdge(7,9);
+
+	g.printGraph();
+	g.outDegree();
+	g.inDegree();
+
+	return 0;
+}

Graph Algorithms/AdjacencyList_IsReachable.cpp

@@ -0,0 +1,82 @@
+#include<iostream>
+#include<vector>
+#include<queue>
+#include<list>
+#include<stack>
+#define Max 10
+using namespace std;
+
+class Graph{
+	list<int> adjlist[Max];
+
+	public:
+	void addEdge(int u,int v){
+		adjlist[u].push_back(v);
+		//if undirected
+		//adjlist[v].push_back(u);
+	}
+	void printGraph(){
+		list<int>::iterator it;
+
+		for(int i=0;i<Max;i++){
+			cout<<i<<"->";
+			for(it=adjlist[i].begin();it!=adjlist[i].end();++it){
+				cout<<*it<<"-";
+			}
+			cout<<"/\n";
+		}
+		cout<<"\n\n";
+	}
+
+	void isreachable(int u,int v){
+		bool visited[Max]={false};
+		list<int>::iterator it;
+		int check=0;
+		queue<int> q;
+		visited[u]=true;
+		q.push(u);
+		while(!q.empty()){
+			int d=q.front();
+			q.pop();
+			if(d==v){
+				check=1;
+			}
+			for(it=adjlist[d].begin();it!=adjlist[d].end();++it){
+				if(visited[*it]==false){
+					visited[*it]=true;
+					q.push(*it);
+				}	
+			}
+
+		}
+		if(check){
+			cout<<"The edge "<<v<<" is reachable from "<<u<<endl;
+		}else{
+			cout<<"The edge "<<v<<" is not reachable from "<<u<<endl;
+		}
+		cout<<"\n";
+		return;
+
+	}
+
+
+};
+
+int main(){
+	Graph graph;
+	graph.addEdge(1,3);
+	graph.addEdge(3,1);
+	graph.addEdge(6,10);
+	graph.addEdge(2,6);
+	graph.addEdge(6,4);
+	graph.addEdge(4,5);
+	graph.addEdge(8,6);
+
+	graph.isreachable(1,3);
+	graph.printGraph();
+
+
+
+
+	return 0;
+}

Graph Algorithms/AdjaceneyListIsCyclic.cpp

@@ -0,0 +1,96 @@
+#include<iostream>
+#include<vector>
+#include<queue>
+#include<list>
+#include<stack>
+#define Max 10
+using namespace std;
+
+class Graph{
+	list<int> adjlist[Max];
+
+	public:
+	void addEdge(int u,int v){
+		adjlist[u].push_back(v);
+		//if undirected
+		//adjlist[v].push_back(u);
+	}
+	void printGraph(){
+		list<int>::iterator it;
+
+		for(int i=0;i<Max;i++){
+			cout<<i<<"->";
+			for(it=adjlist[i].begin();it!=adjlist[i].end();++it){
+				cout<<*it<<"-";
+			}
+			cout<<"/\n";
+		}
+		cout<<"\n\n";
+	}
+
+
+	private:
+	bool isCyclicUtil(int v, bool visited[], bool recStack[]){ 
+	    if(visited[v] == false) 
+	    { 
+
+	        visited[v] = true; 
+	        recStack[v] = true; 
+
+
+	        list<int>::iterator it; 
+	        for(it = adjlist[v].begin(); it != adjlist[v].end(); ++it) 
+	        { 
+	            if ( !visited[*it] && isCyclicUtil(*it, visited, recStack) ) 
+	                return true; 
+	            else if (recStack[*it]) 
+	                return true; 
+	        } 
+
+	    } 
+	    recStack[v] = false;  
+	    return false; 
+	} 
+
+	public:
+	bool isCyclic(){ 
+	    bool visited[Max];
+	    bool recStack[Max];
+	    for(int i = 0; i < Max; i++){ 
+	        visited[i] = false; 
+	        recStack[i] = false; 
+	    } 
+
+	    for(int i = 0; i < Max; i++) 
+	        if (isCyclicUtil(i, visited, recStack)) 
+	            return true; 
+
+	    return false; 
+	} 
+
+};
+
+int main(){
+	Graph g;
+	g.addEdge(1,2);
+	g.addEdge(3,1);
+	g.addEdge(2,3);
+	g.addEdge(3,4);
+	g.addEdge(4,5);
+	g.addEdge(5,6);
+	g.addEdge(6,7);
+	g.addEdge(7,8);
+	g.addEdge(7,9);
+
+	g.printGraph();
+
+
+	if(g.isCyclic()){
+		cout<<"Graph is cyclic"<<endl;
+	}else{
+		cout<<"Graph is not cyclic"<<endl;
+	}
+
+
+	return 0;
+}