C++ Programs with Outputs

Recursive Binary Search and Linear Search

#include <iostream>
#include <vector>
using namespace std;

// Recursive Linear Search

int linearSearch(const vector<int>& arr, int index, int key) {
if (index >= arr.size()) return -1;
if (arr[index] == key) return index;
return linearSearch(arr, index + 1, key);
}

// Recursive Binary Search

int binarySearch(const vector<int>& arr, int low, int high, int key) {
if (low > high) return -1;
int mid = low + (high - low) / 2;
if (arr[mid] == key) return mid;
if (arr[mid] > key) return binarySearch(arr, low, mid - 1, key);
return binarySearch(arr, mid + 1, high, key);
}

int main() {
vector<int> arr = {1, 3, 5, 7, 9, 11};
int key = 7;

cout << "Linear Search Result: " << linearSearch(arr, 0, key) << endl;
cout << "Binary Search Result: " << binarySearch(arr, 0, arr.size() - 1, key) << endl;
return 0;
}

Heap Sort

#include <iostream>
#include <vector>
using namespace std;

void heapify(vector<int>& arr, int n, int i) {

int largest = i;
 int left = 2 * i + 1;
int right = 2 * i + 2;

if (left < n && arr[left] > arr[largest]) largest = left;

if (right < n && arr[right] > arr[largest]) largest = right;
if (largest != i) {
swap(arr[i], arr[largest]);
heapify(arr, n, largest);
}
}

void heapSort(vector<int>& arr) {

int n = arr.size();
for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i);
for (int i = n - 1; i > 0; i--) {
swap(arr[0], arr[i]);
heapify(arr, i, 0);
}
}

int main() {
vector<int> arr = {4, 10, 3, 5, 1};
heapSort(arr);
for (int i : arr) cout << i << " ";
cout << endl;
return 0;
}

Merge Sort

#include <iostream>
#include <vector>
using namespace std;

void merge(vector<int>& arr, int left, int mid, int right) {

int n1 = mid - left + 1;
int n2 = right - mid;

vector<int> L(n1), R(n2);

for (int i = 0; i < n1; i++) L[i] = arr[left + i];
for (int j = 0; j < n2; j++) R[j] = arr[mid + 1 + j];

int i = 0, j = 0, k = left;
 while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}

while (i < n1) arr[k++] = L[i++];

while (j < n2) arr[k++] = R[j++];
}

void mergeSort(vector<int>& arr, int left, int right) {

if (left >= right) return;
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}

int main() {
vector<int> arr = {12, 11, 13, 5, 6, 7};
mergeSort(arr, 0, arr.size() - 1);
for (int i : arr) cout << i << " ";
cout << endl;
return 0;
}

Selection Sort

#include <iostream>
#include <vector>
using namespace std;

void selectionSort(vector<int>& arr) {

for (int i = 0; i < arr.size() - 1; i++) {
int minIdx = i;
for (int j = i + 1; j < arr.size(); j++) {
if (arr[j] < arr[minIdx]) minIdx = j;
}
 swap(arr[i], arr[minIdx]);
}
}

int main() {
vector<int> arr = {64, 25, 12, 22, 11};
selectionSort(arr);
for (int i : arr) cout << i << " ";
cout << endl;
return 0;
}

Insertion Sort

#include <iostream>
#include <vector>
using namespace std;

void insertionSort(vector<int>& arr) {

for (int i = 1; i < arr.size(); i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}

int main() {
vector<int> arr = {12, 11, 13, 5, 6};
insertionSort(arr);
for (int i : arr) cout << i << " ";
cout << endl;
return 0;
}

Quick Sort

#include <iostream>
#include <vector>
using namespace std;

int partition(vector<int>& arr, int low, int high) {

int pivot = arr[high];
int i = low - 1;

for (int j = low; j < high; j++) {

if (arr[j] < pivot) {
i++;
swap(arr[i], arr[j]);
}
}
swap(arr[i + 1], arr[high]);
return i + 1;
}

void quickSort(vector<int>& arr, int low, int high) {

if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}

int main() {
vector<int> arr = {10, 7, 8, 9, 1, 5};
quickSort(arr, 0, arr.size() - 1);
for (int i : arr) cout << i << " ";
cout << endl;
return 0;
}

Knapsack Problem (Greedy)

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct Item {
int value, weight;
double ratio;
};
bool compare(Item a, Item b) {
return a.ratio > b.ratio;
}

double knapsackGreedy(vector<Item>& items, int W) {

sort(items.begin(), items.end(), compare);
double totalValue = 0;
for (auto& item : items) {
if (W >= item.weight) {
W -= item.weight;
totalValue += item.value;
} else {
totalValue += item.ratio * W;
break;
}
}
return totalValue;
}

int main() {
vector<Item> items = {{60, 10}, {100, 20}, {120, 30}};
for (auto& item : items) item.ratio = (double)item.value / item.weight;
int W = 50;
cout << "Maximum value in Knapsack = " << knapsackGreedy(items, W) << endl;
return 0;
}

Traveling Salesman Problem (TSP)

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

int tsp(vector<vector<int>>& graph, vector<bool>& visited, int currPos, int n, int count, int
cost, int& ans) {
if (count == n && graph[currPos][0]) {
ans = min(ans, cost + graph[currPos][0]);
return ans;
}

for (int i = 0; i < n; i++) {

 if (!visited[i] && graph[currPos][i]) {
visited[i] = true;
tsp(graph, visited, i, n, count + 1, cost + graph[currPos][i], ans);
visited[i] = false;
}
}
return ans;
}

int main() {
vector<vector<int>> graph = {
{0, 10, 15, 20},
{10, 0, 35, 25},
{15, 35, 0, 30},
{20, 25, 30, 0}
};
int n = graph.size();
vector<bool> visited(n, false);
visited[0] = true;
int ans = INT_MAX;
cout << "Minimum cost of TSP: " << tsp(graph, visited, 0, n, 1, 0, ans) << endl;
return 0;
}

Find Minimum Spanning Tree using Kruskal's Algorithm

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct Edge {
int src, dest, weight;
};

bool compare(Edge a, Edge b) {

return a.weight < b.weight;
}

int findParent(int v, vector<int>& parent) {

if (parent[v] == v) return v;
return parent[v] = findParent(parent[v], parent);
}
void kruskal(vector<Edge>& edges, int V) {
sort(edges.begin(), edges.end(), compare);
vector<int> parent(V);
for (int i = 0; i < V; i++) parent[i] = i;

vector<Edge> result;
int cost = 0;
for (auto& edge : edges) {
int p1 = findParent(edge.src, parent);
int p2 = findParent(edge.dest, parent);

if (p1 != p2) {
result.push_back(edge);
cost += edge.weight;
parent[p1] = p2;
}
}

cout << "Minimum Spanning Tree:" << endl;

for (auto& edge : result) {
cout << edge.src << " - " << edge.dest << " : " << edge.weight << endl;
}
cout << "Total cost: " << cost << endl;
}

int main() {
vector<Edge> edges = {{0, 1, 10}, {0, 2, 6}, {0, 3, 5}, {1, 3, 15}, {2, 3, 4}};
int V = 4; // Number of vertices
kruskal(edges, V);
return 0;
}

Implement N Queen Problem using Backtracking

#include <iostream>
#include <vector>
using namespace std;

bool isSafe(vector<vector<int>>& board, int row, int col, int n) {

for (int i = 0; i < col; i++)
if (board[row][i]) return false;
 for (int i = row, j = col; i >= 0 && j >= 0; i--, j--)
if (board[i][j]) return false;

for (int i = row, j = col; i < n && j >= 0; i++, j--)

if (board[i][j]) return false;

return true;
}

bool solveNQUtil(vector<vector<int>>& board, int col, int n) {

if (col >= n) return true;

for (int i = 0; i < n; i++) {

if (isSafe(board, i, col, n)) {
board[i][col] = 1;
if (solveNQUtil(board, col + 1, n)) return true;
board[i][col] = 0;
}
}
return false;
}

void printSolution(vector<vector<int>>& board, int n) {

for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
cout << board[i][j] << " ";
cout << endl;
}
}

int main() {
int n = 8;
vector<vector<int>> board(n, vector<int>(n, 0));
if (solveNQUtil(board, 0, n))
printSolution(board, n);
else
cout << "Solution does not exist";
return 0;
}