CORE - 14 - Algorithm Design Techiniques
CORE - 14 - Algorithm Design Techiniques
#include <iostream>
using namespace std;
int linearSearch(int arr[], int size, int key) {
for(int i = 0; i < size; i++) {
if(arr[i] == key) {
return i; }
}
return -1;
}
int main() {
int arr[] = {5, 3, 8, 6, 7};
int size = sizeof(arr) / sizeof(arr[0]);
int key;
cout << "Enter the number to search: ";
cin >> key;
int result = linearSearch(arr, size, key);
if(result != -1) {
cout << "Element found at index " << result << endl;
} else {
cout << "Element not found in the array." << endl;
}
return 0;
}
OUTPUT :
#include <iostream>
using namespace std;
int binarySearch(int arr[], int size, int key) {
int low = 0, high = size - 1;
while(low <= high) {
int mid = (low + high) / 2;
if(arr[mid] == key)
return mid;
else if(arr[mid] < key)
low = mid + 1;
else
high = mid - 1;
}
return -1;
}
int main() {
int arr[] = {2, 4, 6, 8, 10, 12, 14};
int size = sizeof(arr) / sizeof(arr[0]);
int key;
cout << "Enter the number to search: ";
cin >> key;
int result = binarySearch(arr, size, key);
if(result != -1)
cout << "Element found at index " << result << endl;
else
cout << "Element not found in the array." << endl;
return 0;
}
OUTPUT :
#include <iostream>
using namespace std;
// Merge two halves
void merge(int arr[], int left, int mid, int right) {
int n1 = mid - left + 1; // size of left half
int n2 = right - mid; // size of right half
// Create temporary arrays
int L[n1], R[n2];
// Copy data to temp arrays
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];
// Merge the temp arrays back into arr[left..right]
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++;
}
// Copy remaining elements of L[], if any
while(i < n1) {
arr[k] = L[i];
i++;
k++;
}
// Copy remaining elements of R[], if any
while(j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
// Merge sort function
void mergeSort(int arr[], int left, int right) {
if(left < right) {
int mid = (left + right) / 2;
// Sort first and second halves
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
// Merge the sorted halves
merge(arr, left, mid, right);
}
}
// Print array
void printArray(int arr[], int size) {
for(int i = 0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}
int main() {
int arr[] = {9, 4, 6, 2, 10, 1};
int size = sizeof(arr) / sizeof(arr[0]);
cout << "Original array: ";
printArray(arr, size);
mergeSort(arr, 0, size - 1);
cout << "Sorted array: ";
printArray(arr, size);
return 0;
}
OUTPUT :
Original array: 9 4 6 2 10 1
Sorted array: 1 2 4 6 9 10
#include <iostream>
using namespace std;
int partition(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(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);
}
}
void printArray(int arr[], int size) {
for(int i = 0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}
int main() {
int arr[] = {7, 2, 1, 6, 8, 5, 3, 4};
int size = sizeof(arr) / sizeof(arr[0]);
cout << "Original array: ";
printArray(arr, size);
quickSort(arr, 0, size - 1);
cout << "Sorted array: ";
printArray(arr, size);
return 0;
}
OUTPUT :
Original array: 7 2 1 6 8 5 3 4
Sorted array: 1 2 3 4 5 6 7 8
#include <iostream>
using namespace std;
// Function to heapify a subtree rooted at index i
void heapify(int arr[], int n, int i) {
int largest = i; // Initialize largest as root
int left = 2 * i + 1; // left child index
int right = 2 * i + 2;// right child index
// If left child is larger than root
if(left < n && arr[left] > arr[largest])
largest = left;
// If right child is larger than largest so far
if(right < n && arr[right] > arr[largest])
largest = right;
// If largest is not root
if(largest != i) {
swap(arr[i], arr[largest]); // Swap root with largest
heapify(arr, n, largest); // Recursively heapify the affected
sub-tree
}
}
// Heap sort function
void heapSort(int arr[], int n) {
// Build max heap
for(int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
// Extract elements from heap one by one
for(int i = n - 1; i > 0; i--) {
swap(arr[0], arr[i]); // Move current root to end
heapify(arr, i, 0); // Heapify the reduced heap
}
}
// Print the array
void printArray(int arr[], int size) {
for(int i = 0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}
int main() {
int arr[] = {12, 11, 13, 5, 6, 7};
int size = sizeof(arr) / sizeof(arr[0]);
cout << "Original array: ";
printArray(arr, size);
heapSort(arr, size);
cout << "Sorted array: ";
printArray(arr, size);
return 0;
}
OUTPUT :
Original array: 12 11 13 5 6 7
Sorted array: 5 6 7 11 12 13
OUTPUT :
#include <iostream>
#include <vector>
using namespace std;
class Graph {
int V; // Number of vertices
vector<vector<int>> adj;
public:
Graph(int v) {
V = v;
adj.resize(V);
}
void addEdge(int u, int v) {
adj[u].push_back(v); // Add v to u's list
adj[v].push_back(u); // For undirected graph
}
void DFSUtil(int node, vector<bool>& visited) {
visited[node] = true;
cout << node << " ";
for (int neighbor : adj[node]) {
if (!visited[neighbor]) {
DFSUtil(neighbor, visited);
}
}
}
void DFS(int start) {
vector<bool> visited(V, false);
cout << "DFS Traversal starting from node " << start << ": ";
DFSUtil(start, visited);
cout << endl;
}
};
int main() {
Graph g(6);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 3);
g.addEdge(2, 4);
g.addEdge(3, 5);
g.addEdge(4, 5);
g.DFS(0);
return 0;
}
OUTPUT :
DFS Traversal starting from node 0: 0 1 3 5 4 2
8. Write a Program to implement Bubble Sort in C++
#include <iostream>
using namespace std;
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
bool swapped = false;
for (int j = 0; j < n - i - 1; j++) {
// Swap if the element is greater than the next one
if (arr[j] > arr[j + 1]) {
swap(arr[j], arr[j + 1]);
swapped = true;
}
}
// If no two elements were swapped, the array is already sorted
if (!swapped)
break;
}
}
void printArray(int arr[], int n) {
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
}
int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr)/sizeof(arr[0]);
cout << "Original array: ";
printArray(arr, n);
bubbleSort(arr, n);
cout << "Sorted array: ";
printArray(arr, n);
return 0;
}
OUTPUT :
Original array: 64 34 25 12 22 11 90
Sorted array: 11 12 22 25 34 64 90
#include <iostream>
using namespace std;
void insertionSort(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i]; // Current element to be inserted
int j = i - 1;
// Shift elements of arr[0..i-1] that are greater than key
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j]; // Move element one position ahead
j--;
}
arr[j + 1] = key; // Insert key into the correct position
}
}
void printArray(int arr[], int n) {
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
cout << endl;
}
int main() {
int arr[] = {29, 10, 14, 37, 13};
int n = sizeof(arr)/sizeof(arr[0]);
cout << "Original array: ";
printArray(arr, n);
insertionSort(arr, n);
cout << "Sorted array: ";
printArray(arr, n);
return 0;
}
OUTPUT :
Original array: 29 10 14 37 13
Sorted array: 10 13 14 29 37
OUTPUT :
Original array: 64 25 12 22 11
Sorted array: 11 12 22 25 64