1.

Recurisve and Non recursive

#include <iostream>
using namespace std;
int binarySearchRecursive(int arr[], int left, int right, int target) {
if (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == target)
return mid;
if (arr[mid] > target)
return binarySearchRecursive(arr, left, mid - 1, target);
return binarySearchRecursive(arr, mid + 1, right, target);
}
return -1;
}
int binarySearchNonRecursive(int arr[], int size, int target) {
int left = 0, right = size - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == target)
return mid;
if (arr[mid] > target)
right = mid - 1;
else
left = mid + 1;
}
return -1; // Target not found
}
int main() {
int arr[] = {2, 4, 6, 8, 10, 12, 14};
int size = sizeof(arr) / sizeof(arr[0]);
int target;
cout << "Enter the element to search: ";
cin >> target;

int resultRecursive = binarySearchRecursive(arr, 0, size - 1, target);

if (resultRecursive != -1)
cout << "Element found at index (Recursive): " << resultRecursive << endl;
else
cout << "Element not found (Recursive)" << endl;
int resultNonRecursive = binarySearchNonRecursive(arr, size, target);
if (resultNonRecursive != -1)
cout << "Element found at index (Non-Recursive): " << resultNonRecursive << endl;
else
cout << "Element not found (Non-Recursive)" << endl; return 0;}
2a) Merge Sort
#include <iostream>
using namespace std;
void mergeSort(int a[],int l,int r)
{
if (l>=r)return;
int m=(l+r)/2,t[100],i=l,j=m+1,k=0;
mergeSort(a,l,m),mergeSort(a,m+1,r);
while(i<=m && j<=r) t[k++] = (a[i]<a[j]) ? a[i++] : a[j++];
while(i<=m) t[k++]=a[i++];
while(j<=r) t[k++]=a[j++];
for (i=l,k=0;i<=r;a[i++]=t[k++]);
}
int main()
{
int n,a[100];
cout<<"Enter no. of elements:";
cin>>n;
cout<<"Enter element:";
for(int i=0;i<n;cin>>a[i++]);
mergeSort(a,0,n-1);
cout<<"Sorted List:";
for(int i=0;i<n;cout<<a[i++]<<" ");}
2b) Heap Sort
#include <iostream>
using namespace std;
void heapify(int a[], int n, int i) {
int l = 2 * i + 1, r = 2 * i + 2, largest = i;
if (l < n && a[l] > a[largest]) largest = l;
if (r < n && a[r] > a[largest]) largest = r;
if (largest != i) { swap(a[i], a[largest]); heapify(a, n, largest); }
}
void heapSort(int a[], int n) {
for (int i = n / 2 - 1; i >= 0; i--) heapify(a, n, i);
for (int i = n - 1; i > 0; i--) { swap(a[0], a[i]); heapify(a, i, 0); }
}
int main() {
int n, a[100];
cout << "Enter number of elements: ";
cin >> n;
cout << "Enter elements: ";
for (int i = 0; i < n; i++) cin >> a[i];
heapSort(a, n);
cout<<"Heapify Sorted List:";
for (int i = 0; i < n; i++) cout << a[i] << " ";
}
3) Inorder Traversal

#include <iostream>
using namespace std;
struct Node{
int data;
Node* left;
Node*right;
Node(int value): data(value),left(NULL),right(NULL){
}
};
void preOrderTraversal(Node * root){
if(!root)return;
cout<<root->data<<" ";
preOrderTraversal(root->left);
preOrderTraversal(root->right);
}
int main(){
int rov,lv,rv,llv,rlv;

cout<<"Enter root Value:";

cin>>rov;
Node*root=new Node(rov);

cout<<"Enter left child:";

cin>>lv;
if(lv!=-1)root->left=new Node(lv);
cout<<"Enter right child:";
cin>>rv;
if(rv!=-1)root->right=new Node(rv);

cout<<"Enter left left child:";

cin>>llv;
if(llv!=-1)root->left->left=new Node(llv);

cout<<"Enter right left child:";

cin>>rlv;
if(rlv!=-1)root->right->left=new Node(rlv);

cout<<"Preorder Traversal:";
preOrderTraversal(root);
cout<<endl;
return 0;}
4) Two Path

#include <iostream>
using namespace std;
const int MAX = 1000;
int adj[MAX][MAX] = {0};
bool visited[MAX] = {false};
bool dfs(int curr, int target, int n) {
if (curr == target) return true;
visited[curr] = true;
for (int i = 0; i < n; i++)
if (adj[curr][i] && !visited[i] && dfs(i, target, n))
return true;
return false;
}
int main() {
int n, m, u, v, start, end;
cout << "Enter the number of vertices: ";
cin >> n;
cout << "Enter the number of edges: ";
cin >> m;
cout << "Enter the edges (from to):" << endl;
while (m--) cin >> u >> v, adj[u][v] = adj[v][u] = 1;
cout << "Enter the start and end vertices: ";
cin >> start >> end;
cout << (dfs(start, end, n) ? "There is a path exists" : "No path exists") << endl;
return 0;
}
5) Fibonnaci
#include <iostream>
using namespace std;
struct TreeNode {
int val;
TreeNode *left, *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
int dfs(TreeNode* node, int prev1, int prev2) {
if (!node) return 0;
int count = (node->val == prev1 + prev2) ? 1 : 0;
return count + dfs(node->left, prev1 + prev2, prev1) + dfs(node->right, prev1 + prev2,
prev1);}
int countFibonacciPaths(TreeNode* root) {
if (!root) return 0;
return dfs(root, 0, root->val) + countFibonacciPaths(root->left) +
countFibonacciPaths(root->right);
}
int main() {
TreeNode* root = new TreeNode(5);
root->left = new TreeNode(3);
root->right = new TreeNode(8);
root->left->left = new TreeNode(2);
root->left->right = new TreeNode(4);
root->right->left = new TreeNode(7);
root->right->right = new TreeNode(10);
cout << "Number of Fibonacci paths: " << countFibonacciPaths(root) << endl;
return 0;}
7a) prime
#include <iostream>
using namespace std;
bool isPrime(int n) {
if (n <= 1) return false;
for (int i = 2; i <= n / 2; i++) {
if (n % i == 0) return false;
}
return true;
}
int main() {
int limit;
cout<<"Enter the number:";
cin >> limit;
for (int i = 2; i <= limit; i++) {
if (isPrime(i))
cout << i << " ";
cout;
}
return 0;
}
7b) gcd

#include <iostream>
using namespace std;
int gcd(int a, int b) {
return (b == 0) ? a : gcd(b, a % b);
}
int main() {
int a, b;
cout<<"Enter the number a & b :";
cin >> a >> b;
cout << "GCD of given Number is "<<" "<<gcd(a, b);
return 0;
}
8) dfs:
#include <iostream>
using namespace std;
void DFS(int node, int** adj, bool visited[], int vertices) {
visited[node] = true;
cout << node << " ";
for (int i = 0; i < vertices; i++) {
if (adj[node][i] == 1 && !visited[i]) {
DFS(i, adj, visited, vertices);
}}}
int main() {
int vertices;
cout << "Enter number of vertices: ";
cin >> vertices;
int** adj = new int*[vertices];
for (int i = 0; i < vertices; i++) {
adj[i] = new int[vertices];}
cout << "Enter the adjacency matrix (0 or 1 for each pair of nodes):\n";
for (int i = 0; i < vertices; i++) {
for (int j = 0; j < vertices; j++) {
cin >> adj[i][j];}}
bool* visited = new bool[vertices]();
cout << "DFS Traversal: ";
DFS(0, adj, visited, vertices);
return 0;
}
9) kruskal algorithm

#include <iostream>
#include <algorithm>
using namespace std;
class UnionFind {
public:
int *parent, *rank;
UnionFind(int n) {
parent = new int[n]; rank = new int[n];
for (int i = 0; i < n; i++) parent[i] = i, rank[i] = 0;
}
int find(int u) { return parent[u] != u ? parent[u] = find(parent[u]) : u; }
void unite(int u, int v) { int root_u = find(u), root_v = find(v); if (root_u != root_v) {
if (rank[root_u] > rank[root_v]) parent[root_v] = root_u;
else { parent[root_u] = root_v; if (rank[root_u] == rank[root_v]) rank[root_v]++; } } }
};
struct Edge { int u, v, weight; bool operator<(Edge &e) { return weight < e.weight; } };
int main() {
int n, e_count;
cout << "Enter number of vertices: ";
cin >> n;
cout << "Enter number of edges: ";
cin >> e_count;
Edge edges[e_count];
cout << "Enter edges (u, v, weight):\n";
for (int i = 0; i < e_count; i++) cin >> edges[i].u >> edges[i].v >> edges[i].weight;
UnionFind uf(n);
sort(edges, edges + e_count);
 cout << "MST edges:\n";
for (int i = 0; i < e_count; i++) {
if (uf.find(edges[i].u) != uf.find(edges[i].v)) {
uf.unite(edges[i].u, edges[i].v);
cout << edges[i].u << " - " << edges[i].v << ": " << edges[i].weight << endl;
}}
return 0;
}
10) Bellman ford
#include <iostream>
#include <climits>
using namespace std;
void bellmanFord(int n, int m, int roads[][3], int start) {
int dist[n];
for (int i = 0; i < n; i++) dist[i] = INT_MAX;
dist[start] = 0;
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < m; j++)
if (dist[roads[j][0]] != INT_MAX && dist[roads[j][0]] + roads[j][2] < dist[roads[j][1]])
dist[roads[j][1]] = dist[roads[j][0]] + roads[j][2];
for (int i = 0; i < n; i++) {
cout << "Place " << i << ": ";
if (dist[i] == INT_MAX) cout << "Too far\n";
else cout << dist[i] << "\n";
}
}
int main() {
int n, m, roads[100][3], start;
cout << "Enter vertices, edges: ";
cin >> n >> m;
cout << "Enter edges (u v w):\n";
for (int i = 0; i < m; i++) cin >> roads[i][0] >> roads[i][1] >> roads[i][2];
cout << "Enter source vertex: ";
cin >> start;
bellmanFord(n, m, roads, start);
}
11) Push Pop Heap

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int arr[10], n;
cout << "Enter number of elements: ";
cin >> n;
cout << "Enter " << n << " numbers: ";
for (int i = 0; i < n; ++i) {cin >> arr[i];}
make_heap(arr, arr + n);
cout << "Heap: ";
for (int i = 0; i < n; ++i) {cout << arr[i] << " ";}
cout << endl;

int newElem;
cout << "Enter a number to add: ";
cin >> newElem;
arr[n] = newElem;
n++;
push_heap(arr, arr + n);
cout << "Heap after adding: ";
for (int i = 0; i < n; ++i) {cout << arr[i] << " ";}
cout << endl;
pop_heap(arr, arr + n);

int largest = arr[n - 1];n--;

cout << "Heap after pop_heap: ";
 for (int i = 0; i < n; ++i) {cout << arr[i] << " ";}
cout << endl;
cout << "Popped element: " << largest << endl;
return 0;
}
12) Huffman Coding

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct Node { char item; int freq; Node* left, *right;};
struct Compare {
bool operator()(Node* a, Node* b) { return a->freq > b->freq;}
};
void printHuffmanCodes(Node* root, string str)
{
if (root == NULL) return;
if (root->left == NULL && root->right == NULL) {
cout << root->item << ": " << str << endl;
return;
}
printHuffmanCodes(root->left, str + "0");
printHuffmanCodes(root->right, str + "1");
}
void HuffmanCodes(char item[], int freq[], int size)
{
priority_queue<Node*, vector<Node*>, Compare> pq;
for (int i = 0; i < size; i++) {
Node* newNode = new Node();
newNode->item = item[i];
newNode->freq = freq[i];
newNode->left = newNode->right = NULL;
pq.push(newNode);
}
while (pq.size() != 1) {
Node* left = pq.top();
pq.pop();
Node* right = pq.top();
pq.pop();
Node* newNode = new Node();
newNode->item = '\0';
newNode->freq = left->freq + right->freq;
newNode->left = left;
newNode->right = right;
pq.push(newNode);
}
printHuffmanCodes(pq.top(), "");
}

int main() {
char item[] = {'A', 'B', 'C', 'D'};
int freq[] = {5, 1, 6, 3};
int size = sizeof(item) / sizeof(item[0]);
cout << "Character | Huffman code" << endl;
HuffmanCodes(item, freq, size);
return 0;
}
13) Djikstra’s Algorithm

#include <iostream>
#include <queue>
#include <climits>
using namespace std;
const int INF = INT_MAX;
void dijkstra(int graph[10][10], int N, int src) {
int dist[10], visited[10] = {0};
for (int i = 0; i < N; ++i) dist[i] = INF;
dist[src] = 0;
priority_queue<pair<int, int>, deque<pair<int, int> >, greater<pair<int, int> > > pq;
pq.push({0, src});
while (!pq.empty()) {
int u = pq.top().second; pq.pop();
if (visited[u]) continue;
visited[u] = 1;
for (int v = 0; v < N; ++v)
if (graph[u][v] && dist[u] + graph[u][v] < dist[v])
dist[v] = dist[u] + graph[u][v], pq.push({dist[v], v});
}
for (int i = 0; i < N; ++i)
cout << "Node " << i << ": " << dist[i] << "\n";}
int main() {
int N, src, graph[10][10];
cout << "Enter number of vertices: ";
cin >> N;
cout << "Enter the adjacency matrix:\n";
for (int i = 0; i < N; ++i)
 for (int j = 0; j < N; ++j)
cin >> graph[i][j];
cout << "Enter the starting node: ";
cin >> src;
dijkstra(graph, N, src);
}
14) LCS
#include <iostream>
#include <climits>
using namespace std;
int LCS(string s1, string s2) {
int m = s1.length(), n = s2.length();
int dp[100][100] = {0};
for (int i = 1; i <= m; ++i)
for (int j = 1; j <= n; ++j)
dp[i][j] = (s1[i - 1] == s2[j - 1]) ? dp[i - 1][j - 1] + 1 : max(dp[i - 1][j], dp[i][j - 1]);
return dp[m][n];
}
int main() {
cout << "Length of LCS: " << LCS("stone", "longest") << endl;
return 0;
}
15)activity selection:

#include <iostream>
using namespace std;
void activitySelection(int start[], int finish[], int n) {
int i = 0;
cout << "Selected activities: " << i << " ";
for (int j = 1; j < n; ++j)
if (start[j] >= finish[i]) { cout << j << " "; i = j; }
}
int main() {
int n;
cout << "Enter number of activities: ";
cin >> n;
int start[n], finish[n];
cout << "Enter start times: ";
for (int i = 0; i < n; ++i) cin >> start[i];
cout << "Enter finish times: ";
for (int i = 0; i < n; ++i) cin >> finish[i];
activitySelection(start, finish, n);
return 0;
}