added breadth first search program

Advanced/breadth_first_search.cpp

@@ -0,0 +1,92 @@
+#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() 
+{ 
+    // Create a graph given in the above diagram 
+    Graph g(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); 
+
+    cout << "Following is Breadth First Traversal "
+         << "(starting from vertex 2) \n"; 
+    g.BFS(2); 
+
+    return 0; 
+} 

Advanced/depth_first_search_program.cpp

@@ -0,0 +1,84 @@
+#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); 
+} 
+
+// Driver code 
+int main() 
+{ 
+    // Create a graph given in the above diagram 
+    Graph g(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); 
+
+    cout << "Following is Depth First Traversal"
+            " (starting from vertex 2) \n"; 
+    g.DFS(2); 
+
+    return 0; 
+} 

Beginner/EvEn_OdD.py

@@ -0,0 +1,5 @@
+num = int(input("Enter a number: "))
+if (num % 2) == 0:
+   print("{0} is Even".format(num))
+else:
+   print("{0} is Odd".format(num))

Beginner/FiB_SeR13.py

@@ -0,0 +1,14 @@
+    def recur_fibo(n):  
+       if n <= 1:  
+           return n  
+       else:  
+           return(recur_fibo(n-1) + recur_fibo(n-2))  
+    # take input from the user  
+    nterms = int(input("How many terms? "))  
+    # check if the number of terms is valid  
+    if nterms <= 0:  
+       print("Plese enter a positive integer")  
+    else:  
+       print("Fibonacci sequence:")  
+       for i in range(nterms):  
+           print(recur_fibo(i))  

Intermediate/QuIcK_SoRt13.py

@@ -0,0 +1,27 @@
+def partition(arr,low,high): 
+    i = ( low-1 )         # index of smaller element 
+    pivot = arr[high]     # pivot 
+
+    for j in range(low , high): 
+
+        # If current element is smaller than or 
+        # equal to pivot 
+        if   arr[j] <= pivot: 
+
+            # increment index of smaller element 
+            i = i+1 
+            arr[i],arr[j] = arr[j],arr[i] 
+
+    arr[i+1],arr[high] = arr[high],arr[i+1] 
+    return ( i+1 ) 
+  def quickSort(arr,low,high): 
+    if low < high: 
+
+        # pi is partitioning index, arr[p] is now 
+        # at right place 
+        pi = partition(arr,low,high) 
+
+        # Separately sort elements before 
+        # partition and after partition 
+        quickSort(arr, low, pi-1) 
+        quickSort(arr, pi+1, high) 

PaLiN.py

@@ -0,0 +1,12 @@
+
+n=int(input("Enter number:"))
+temp=n
+rev=0
+while(n>0):
+    dig=n%10
+    rev=rev*10+dig
+    n=n//10
+if(temp==rev):
+    print("The number is a palindrome!")
+else:
+    print("The number isn't a palindrome!")