diff --git a/Advanced/breadth_first_search.cpp b/Advanced/breadth_first_search.cpp new file mode 100644 index 00000000..6afb0788 --- /dev/null +++ b/Advanced/breadth_first_search.cpp @@ -0,0 +1,92 @@ +#include +#include + +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 *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[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 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::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; +} diff --git a/Advanced/depth_first_search_program.cpp b/Advanced/depth_first_search_program.cpp new file mode 100644 index 00000000..3ca00486 --- /dev/null +++ b/Advanced/depth_first_search_program.cpp @@ -0,0 +1,84 @@ +#include +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 *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[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::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; +} diff --git a/Beginner/EvEn_OdD.py b/Beginner/EvEn_OdD.py new file mode 100644 index 00000000..dbf47163 --- /dev/null +++ b/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)) diff --git a/Beginner/FiB_SeR13.py b/Beginner/FiB_SeR13.py new file mode 100644 index 00000000..9d9db527 --- /dev/null +++ b/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)) diff --git a/Intermediate/QuIcK_SoRt13.py b/Intermediate/QuIcK_SoRt13.py new file mode 100644 index 00000000..c9e3d957 --- /dev/null +++ b/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) diff --git a/PaLiN.py b/PaLiN.py new file mode 100644 index 00000000..ebb9b96c --- /dev/null +++ b/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!")