5 Searching Algorithms added in C++

C++/Searching/BinarySearch.cpp

@@ -0,0 +1,30 @@
+#include<iostream>
+#include<bits/stdc++.h>
+using namespace std;
+
+int binarySearch(int arr[], int n, int key){
+    int end = n-1;
+    int start = 0;
+
+    while(start <= end){
+        int mid = (start + end)/2;
+
+        if(arr[mid]<key){
+            start = mid+1;
+        }
+        else if(arr[mid]>key) {
+            end = mid - 1;
+        }
+        else {
+            cout<<"Element found "<<endl;
+            break;
+        }
+
+    }
+
+}
+
+int main() {
+
+    return 0;
+}

C++/Searching/BreadthFirstSearch.cpp

@@ -0,0 +1,104 @@
+// Program to print BFS traversal from a given 
+// source vertex. BFS(int s) traverses vertices 
+// reachable from s. 
+#include<iostream> 
+#include <list> 
+
+using namespace std; 
+
+// This class represents a directed graph using 
+// adjacency list representation 
+class Graph 
+{ 
+	int V; // No. of vertices 
+
+	// Pointer to an array containing adjacency 
+	// lists 
+	list<int> *adj; 
+public: 
+	Graph(int V); // Constructor 
+
+	// function to add an edge to graph 
+	void addEdge(int v, int w); 
+
+	// prints BFS traversal from a given source s 
+	void BFS(int s); 
+}; 
+
+Graph::Graph(int V) 
+{ 
+	this->V = V; 
+	adj = new list<int>[V]; 
+} 
+
+void Graph::addEdge(int v, int w) 
+{ 
+	adj[v].push_back(w); // Add w to v’s list. 
+} 
+
+void Graph::BFS(int s) 
+{ 
+	// Mark all the vertices as not visited 
+	bool *visited = new bool[V]; 
+	for(int i = 0; i < V; i++) 
+		visited[i] = false; 
+
+	// Create a queue for BFS 
+	list<int> queue; 
+
+	// Mark the current node as visited and enqueue it 
+	visited[s] = true; 
+	queue.push_back(s); 
+
+	// 'i' will be used to get all adjacent 
+	// vertices of a vertex 
+	list<int>::iterator i; 
+
+	while(!queue.empty()) 
+	{ 
+		// Dequeue a vertex from queue and print it 
+		s = queue.front(); 
+		cout << s << " "; 
+		queue.pop_front(); 
+
+		// Get all adjacent vertices of the dequeued 
+		// vertex s. If a adjacent has not been visited, 
+		// then mark it visited and enqueue it 
+		for (i = adj[s].begin(); i != adj[s].end(); ++i) 
+		{ 
+			if (!visited[*i]) 
+			{ 
+				visited[*i] = true; 
+				queue.push_back(*i); 
+			} 
+		} 
+	} 
+} 
+
+// Driver program to test methods of graph class 
+int main() 
+{ 
+
+
+int n=100,ch=1;
+    cout<<"Enter n.o of vertices\n";
+    cin>>n;
+    Graph g(n);
+    do
+    {   int a,b;
+        cout<<"Enter 2 vertices between which you want to add edge\n";
+        cin>>a>>b;
+        g.addEdge(a,b);
+        cout<<"You want to add new edge press 1\n";
+        cin>>ch;
+    }
+    while(ch==1);
+        int bfs_node;
+    cout<<"Enter BFS starting vertex";
+    cin>>bfs_node;
+    	cout << "Following is Breadth First Traversal "
+		<< "(starting from vertex "<<bfs_node<<")"<<"\n"; 
+	g.BFS(bfs_node); 
+
+	return 0; 
+}

C++/Searching/DepthFirstSearch.cpp

@@ -0,0 +1,94 @@
+// C++ program to print DFS traversal from 
+// a given vertex in a given graph 
+#include<bits/stdc++.h> 
+using namespace std; 
+
+// Graph class represents a directed graph 
+// using adjacency list representation 
+class Graph 
+{ 
+	int V; // No. of vertices 
+
+	// Pointer to an array containing 
+	// adjacency lists 
+	list<int> *adj; 
+
+	// A recursive function used by DFS 
+	void DFSUtil(int v, bool visited[]); 
+public: 
+	Graph(int V); // Constructor 
+
+	// function to add an edge to graph 
+	void addEdge(int v, int w); 
+
+	// DFS traversal of the vertices 
+	// reachable from v 
+	void DFS(int v); 
+}; 
+
+Graph::Graph(int V) 
+{ 
+	this->V = V; 
+	adj = new list<int>[V]; 
+} 
+
+void Graph::addEdge(int v, int w) 
+{ 
+	adj[v].push_back(w); // Add w to v’s list. 
+} 
+
+void Graph::DFSUtil(int v, bool visited[]) 
+{ 
+	// Mark the current node as visited and 
+	// print it 
+	visited[v] = true; 
+	cout << v << " "; 
+
+	// Recur for all the vertices adjacent 
+	// to this vertex 
+	list<int>::iterator i; 
+	for (i = adj[v].begin(); i != adj[v].end(); ++i) 
+		if (!visited[*i]) 
+			DFSUtil(*i, visited); 
+} 
+
+// DFS traversal of the vertices reachable from v. 
+// It uses recursive DFSUtil() 
+void Graph::DFS(int v) 
+{ 
+	// Mark all the vertices as not visited 
+	bool *visited = new bool[V]; 
+	for (int i = 0; i < V; i++) 
+		visited[i] = false; 
+
+	// Call the recursive helper function 
+	// to print DFS traversal 
+	DFSUtil(v, visited); 
+} 
+
+
+int main() 
+{ 
+
+
+int n=100,ch=1;
+    cout<<"Enter n.o of vertices\n";
+    cin>>n;
+    Graph g(n);
+    do
+    {   int a,b;
+        cout<<"Enter 2 vertices between which you want to add edge\n";
+        cin>>a>>b;
+        g.addEdge(a,b);
+        cout<<"You want to add new edge press 1 \n";
+        cin>>ch;
+    }
+    while(ch==1);
+    int dfs_node;
+    cout<<"Enter DFS starting vertex";
+    cin>>dfs_node;
+    	cout << "Following is Depth First Traversal "
+		<< "(starting from vertex "<<dfs_node<<")"<<"\n"; 
+	g.DFS(dfs_node); 
+	return 0; 
+}

C++/Searching/ExponentialSearch.cpp

@@ -0,0 +1,72 @@
+// C++ program to find an element x in a
+// sorted array using Exponential search.
+#include <bits/stdc++.h>
+using namespace std;
+
+int binarySearch(int arr[], int, int, int);
+
+// Returns position of first occurrence of
+// x in array
+int exponentialSearch(int arr[], int n, int x)
+{
+	// If x is present at firt location itself
+	if (arr[0] == x)
+		return 0;
+
+	// Find range for binary search by
+	// repeated doubling
+	int i = 1;
+	while (i < n && arr[i] <= x)
+		i = i*2;
+
+	// Call binary search for the found range.
+	return binarySearch(arr, i/2, min(i, n), x);
+}
+
+// A recursive binary search function. It returns
+// location of x in given array arr[l..r] is
+// present, otherwise -1
+int binarySearch(int arr[], int l, int r, int x)
+{
+	if (r >= l)
+	{
+		int mid = l + (r - l)/2;
+
+		// If the element is present at the middle
+		// itself
+		if (arr[mid] == x)
+			return mid;
+
+		// If element is smaller than mid, then it
+		// can only be present n left subarray
+		if (arr[mid] > x)
+			return binarySearch(arr, l, mid-1, x);
+
+		// Else the element can only be present
+		// in right subarray
+		return binarySearch(arr, mid+1, r, x);
+	}
+
+	// We reach here when element is not present
+	// in array
+	return -1;
+}
+
+// Driver code
+int main(void)
+{       cout<<"Enter size of array\n";
+        int n;
+        cin>>n;
+        int arr[n];
+        cout<<"Enter array elements";
+        for(int i=0;i<n;i++)
+        {
+            cin>>arr[i];
+        }
+int x;
+cout<<"Enter the Element you want to search\n";
+cin>>x;
+int result = exponentialSearch(arr, n, x);
+(result == -1)? printf("Element is not present in array"): printf("Element is present at index %d",result);
+return 0;
+}

C++/Searching/RecursiveLinearSearch.cpp

@@ -0,0 +1,47 @@
+// Recursive C++ program
+// to search x in array
+#include<bits/stdc++.h>
+
+using namespace std;
+
+// Recursive function to
+// search x in arr[l..r]
+int recSearch(int arr[], int l,
+			int r, int x)
+{
+	if (r < l)
+		return -1;
+	if (arr[l] == x)
+		return l;
+	if (arr[r] == x)
+		return r;
+	return recSearch(arr, l + 1,
+						r - 1, x);
+}
+
+// Driver Code
+int main()
+{
+    cout<<"Enter size of array \n";
+        int n;
+        cin>>n;
+        int arr[n];
+        cout<<"Enter array elements";
+        for(int i=0;i<n;i++)
+        {
+            cin>>arr[i];
+        }
+int x;
+cout<<"Enter the Element you want to search\n";
+cin>>x;
+
+	int index = recSearch(arr, 0, n - 1, x);
+	if (index != -1)
+	cout << "Element " << x
+		<< " is present at index "
+		<< index;
+	else
+		cout << "Element" << x
+			<< " is not present" ;
+	return 0;
+}