Adjacency list is bipartite

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/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;
+}

Graph Algorithms/adjacencyList_IsBipartite.cpp

@@ -0,0 +1,79 @@
+#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 isbipartite(){
+		bool visited[Max]={false};
+		int partition[Max]={0};
+		int distance[Max]={0};
+		queue<int> q;
+		list<int>::iterator it;
+		int check=1;
+
+		visited[1]=true;
+		partition[1]=1;
+		distance[1]=0;
+		q.push(1);
+		while(!q.empty()){
+			int u=q.front();
+			for(it=adjlist[u].begin();it!=adjlist[u].end();++it){
+				if(partition[u]==partition[*it]){
+					check=0;
+				}else{
+					if(visited[*it]==false){
+						visited[*it]=true;
+						distance[*it]=distance[u]+1;
+						partition[*it]=3-partition[u];
+						q.push(*it);	
+					}
+				}
+			}
+			q.pop();
+		}
+		if(check){
+			cout<<"This is a bipartite graph"<<endl;
+		}else{
+			cout<<"This is not a bipartite graph"<<endl;
+		}
+		cout<<endl;
+		return;
+	}
+
+};
+
+int main(){
+	Graph bi_true;
+	bi_true.printGraph();
+    bi_true.addEdge(1,2);
+    bi_true.addEdge(1,3);
+    bi_true.addEdge(2,4);
+    bi_true.addEdge(3,5);
+    bi_true.addEdge(4,6);
+    bi_true.addEdge(5,6);
+	bi_true.isbipartite(); 
+	return 0;
+}

String Algorithms/String Matching/Boyer-MooreHorspoolAlgorithm.py

@@ -0,0 +1,48 @@
+import os
+
+CHAR=256
+
+def badCharacterTable(pattern):
+    length=len(pattern)
+    badchar=[length]*CHAR
+
+    for i in range(length-1):
+        badchar[ord(pattern[i])]=length-i
+
+    return badchar
+
+def stringSearch(text,pattern):
+    textlen=len(text)
+    patternlen=len(pattern)
+    badchar=badCharacterTable(pattern)    
+    occurance=[]
+    position=0
+    if(text=="" or pattern==""):
+        print("Text:"+text+"\nPattern:"+pattern+"\nTotal Number matched:"+str(len(occurance))+"\nPositions matched:"+', '.join(occurance))
+        return
+
+    while(position<=(textlen-patternlen)):
+        j=patternlen-1
+        while(j>=0 and (text[position+j]==pattern[j] or pattern[j]=='_')):
+            j=j-1
+
+        if(j==-1):
+            occurance.append(str(position+1))
+            position=position+1
+        else:
+            position=position+ max(1,j-badchar[ord(text[position+j])])
+    print("Text:"+text+"\nPattern:"+pattern+"\nTotal Number matched:"+str(len(occurance))+"\nPositions matched:"+', '.join(occurance))
+
+def main():
+    while (1):
+        text=input("Enter a sample text:")
+        pattern=input("Enter a pattern:")
+        stringSearch(text,pattern)
+        print("\nEnter 1 to test Continue\nEnter 0 to EXIT")
+        n=input("Enter your choise: ")
+        if(n=='0'):
+            return
+
+
+if __name__=="__main__":
+    main()