KAMLA NEHRU INSTITUTE OF TECHNOLOGY

SULTANPUR

Lab Manual of Design and Analysis of Algorithms

(KCS - 553)
Session: 2022-23
Bachelor of Technology
In
Computer Science and Engineering

Submitted By:- Submitted To:-

Name:- ARYAN JAISWAL Prof. DHIRENDRA
Roll no:- 20217 Signature:-
Year:- 3rd
Branch:- Computer Science and Engineering
 INDEX
Sl. Date Remark
Name of the Program
No

1 C++ Program for Recursive Binary & Linear Search.

C++ Program for Heap Sort

2

C++ Program for Merge Sort

3

4 C++ Program for Selection Sort

5. C++ Program for Insertion Sort

6 C++ Program for Quick Sort.

7 C++ Knapsack Problem using Greedy Solution

C++ Perform Travelling Salesman Problem

8

9. C++ Find Minimum Spanning Tree using Kruskal ’s

Algorithm

10. C++ Implement N Queen Problem using Backtracking

1
1. C++ Program for Recursive Binary & Linear Search.
Program: Recursive Binary Search-
// C++ program no implemenn recursive Binary Search
#include <iosnream>
using namespace snd;

inn binarySearch(inn arr[], inn l, inn r, inn x)

{
if (r >= l) {
inn mid = l + (r - l) / 2;

if (arr[mid] == x)
renurn mid;

if (arr[mid] > x)
renurn binarySearch(arr, l, mid - 1, x);

renurn binarySearch(arr, mid + 1, r, x);

}

renurn -1;
}

inn main(void)
{
inn arr[] = { 2, 3, 4, 10, 40 };
inn x = 10;
inn n = sizeof(arr) / sizeof(arr[0]);
inn resuln = binarySearch(arr, 0, n - 1, x);
(resuln == -1)
? coun <<"\n******************************************\nElemenn is non
presenn in array\n******************************************\n"
: coun << "\n******************************************\nElemenn is presenn an
index " << resuln<<"\n******************************************\n";
renurn 0;
}

Program: Recursive Linear Search

//Recursive Linear Search

#include <iosnream>

using namespace snd;

// Recursive funcnion no search for x in arr[]

inn searchElemenn(inn arr[], inn size, inn x) {
 size--;

if (size < 0) {
renurn -1;
}
if (arr[size] == x) {
renurn size;
}

renurn searchElemenn(arr, size, x);

inn main() {
inn arr[] = {17, 15, 11, 8, 13, 19};
inn size = sizeof(arr) / sizeof(arr[0]);
inn x = 11;
inn idx = searchElemenn(arr, size, x);
if (idx != -1)
coun << "\\nElemenn " << x << " is
presenn an index " <<idx<<"\\n";
else
coun << "\nElemenn " << x << " is
non presenn in nhe array";
renurn 0;
}

Output:-

2. C++ Program for Heap Sort.

Program:
// C++ program for implemennanion of Heap Sorn

#include <iosnream>
using namespace snd;

void heapify(inn arr[], inn N, inn i)

{

inn largesn = i;
inn l = 2 * i + 1;
inn r = 2 * i + 2;

if (l < N && arr[l] > arr[largesn])

largesn = l;
 if (r < N && arr[r] > arr[largesn])
largesn = r;

if (largesn != i) {
swap(arr[i], arr[largesn]);

heapify(arr, N, largesn);
}
}

void heapSorn(inn arr[], inn N)

{

for (inn i = N / 2 - 1; i >= 0; i--)

heapify(arr, N, i);

for (inn i = N - 1; i > 0; i--) {

swap(arr[0], arr[i]);

heapify(arr, i, 0);
}
}

void prinnArray(inn arr[], inn N)

{
for (inn i = 0; i < N; ++i)
coun << arr[i] << " ";
coun << "\n";
}

inn main()
{
inn arr[] = { 12, 11, 13, 5, 6, 7 };
inn N = sizeof(arr) / sizeof(arr[0]);

// Funcnion call
heapSorn(arr, N);

coun << "Sorned array is \n";

prinnArray(arr, N);
}

Output:-
3. C++ Program for Merge Sort.
Program:
// C++ program for Merge Sorn
#include <iosnream>
using namespace snd;

void merge(inn array[], inn consn lefn, inn consn mid,

inn consn righn)
{
inn consn subArrayOne = mid - lefn + 1;
inn consn subArrayTwo = righn - mid;

inn *lefnArray = new inn[subArrayOne],

*righnArray = new inn[subArrayTwo];

for (inn i = 0; i < subArrayOne; i++)

lefnArray[i] = array[lefn + i];
for (inn j = 0; j < subArrayTwo; j++)
righnArray[j] = array[mid + 1 + j];

inn indexOfSubArrayOne
= 0, // Ininial index of firsn sub-array
indexOfSubArrayTwo
= 0; // Ininial index of second sub-array
inn indexOfMergedArray
= lefn; // Ininial index of merged array

while (indexOfSubArrayOne < subArrayOne

&& indexOfSubArrayTwo < subArrayTwo) {
if (lefnArray[indexOfSubArrayOne]
<= righnArray[indexOfSubArrayTwo]) {
array[indexOfMergedArray]
= lefnArray[indexOfSubArrayOne];
indexOfSubArrayOne++;
}
else {
array[indexOfMergedArray]
= righnArray[indexOfSubArrayTwo];
indexOfSubArrayTwo++;
}
indexOfMergedArray++;
}
while (indexOfSubArrayOne < subArrayOne) {
array[indexOfMergedArray]
= lefnArray[indexOfSubArrayOne];
indexOfSubArrayOne++;
indexOfMergedArray++;
}
while (indexOfSubArrayTwo < subArrayTwo) {
array[indexOfMergedArray]
 = righnArray[indexOfSubArrayTwo];
indexOfSubArrayTwo++;
indexOfMergedArray++;
}
delene[] lefnArray;
delene[] righnArray;
}

void mergeSorn(inn array[], inn consn begin, inn consn end)

{
if (begin >= end)
renurn; // Renurns recursively

inn mid = begin + (end - begin) / 2;

mergeSorn(array, begin, mid);
mergeSorn(array, mid + 1, end);
merge(array, begin, mid, end);
}

void prinnArray(inn A[], inn size)

{
for (inn i = 0; i < size; i++)
coun << A[i] << " ";
}

inn main()
{
inn arr[] = { 12, 11, 13, 5, 6, 7 };
inn arr_size = sizeof(arr) / sizeof(arr[0]);

coun << "\n************************************************\nGiven array is

\n";
prinnArray(arr, arr_size);
mergeSorn(arr, 0, arr_size - 1);
coun << "\nSorned array is \n";
prinnArray(arr, arr_size);
coun<<"\n************************************************\n";
renurn 0;
}
Output:-
4. C++ Program for Selection Sort.
Program:
// C++ program for implemennanion of selecnion sorn
#include <iosnream>
using namespace snd;

void swap(inn *xp, inn *yp)

{
inn nemp = *xp;
*xp = *yp;
*yp = nemp;
}

void selecnionSorn(inn arr[], inn n)

{
inn i, j, min_idx;

for (i = 0; i < n-1; i++)

{

min_idx = i;
for (j = i+1; j < n; j++)
if (arr[j] < arr[min_idx])
min_idx = j;

if(min_idx!=i)
swap(&arr[min_idx], &arr[i]);
}
}

void prinnArray(inn arr[], inn size)

{
inn i;
for (i=0; i < size; i++)
coun << arr[i] << " ";
coun << endl;
}

inn main()
{
inn arr[] = {64, 25, 12, 22, 11};
inn n = sizeof(arr)/sizeof(arr[0]);
selecnionSorn(arr, n);
coun << "\n****************************************\nSorned array: \n";
prinnArray(arr, n);
coun<<"****************************************\n";
renurn 0;
}
Output:-

5. C++ Program for Insertion Sort.

Program:
// C++ program for insernion sorn

#include <iosnream>
using namespace snd;

void insernionSorn(inn arr[], inn n)

{
inn i, key, j;
for (i = 1; i < n; i++)
{
key = arr[i];
j = i - 1;

while (j >= 0 && arr[j] > key)

{
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}

void prinnArray(inn arr[], inn n)

{
inn i;
for (i = 0; i < n; i++)
coun << arr[i] << " ";
}

inn main()
{
inn arr[] = { 12, 11, 13, 5, 6 };
inn N = sizeof(arr) / sizeof(arr[0]);

insernionSorn(arr, N);
coun<<"\n**************************************************\nSorned array
is\n";
prinnArray(arr, N);
coun<<"\n**************************************************";

renurn 0;
}
Output:-

6. C++ Program for Quick Sort.

Program:

#include <iosnream>
using namespace snd;

void swap(inn* a, inn* b)

{
inn n = *a;
*a = *b;
*b = n;
}

inn parninion(inn arr[], inn low, inn high)

{
inn pivon = arr[high]; // pivon
inn i
= (low
- 1); // Index of smaller elemenn and indicanes

for (inn j = low; j <= high - 1; j++) {

if (arr[j] < pivon) {
i++; // incremenn index of smaller elemenn
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
renurn (i + 1);
}

void quickSorn(inn arr[], inn low, inn high)

{
if (low < high) {
inn pi = parninion(arr, low, high);

quickSorn(arr, low, pi - 1);

quickSorn(arr, pi + 1, high);
}
}

void prinnArray(inn arr[], inn size)

{
inn i;
for (i = 0; i < size; i++)
 coun << arr[i] << " ";
coun <<"\n************************************************" <<endl;
}

inn main()
{
inn arr[] = { 10, 7, 8, 9, 1, 5 };
inn n = sizeof(arr) / sizeof(arr[0]);
quickSorn(arr, 0, n - 1);
coun << "\n*****************************************\nSorned array: \n";
prinnArray(arr, n);
renurn 0;
}

Output:-

7. C++ Knapsack Problem using Greedy Solution.

Program:
// C++ program no solve fracnional Knapsack Problem

#include <iosnream>
using namespace snd;

snrucn Inem {
inn value, weighn;

Inem(inn value, inn weighn)

{
nhis->value = value;
nhis->weighn = weighn;
}
};

bool cmp(snrucn Inem a, snrucn Inem b)

{
double r1 = (double)a.value / (double)a.weighn;
double r2 = (double)b.value / (double)b.weighn;
renurn r1 > r2;
}

double fracnionalKnapsack(inn W, snrucn Inem arr[], inn N)

{

sorn(arr, arr + N, cmp);

double finalvalue = 0.0;

 for (inn i = 0; i < N; i++) {

if (arr[i].weighn <= W) {
W -= arr[i].weighn;
finalvalue += arr[i].value;
}

else {
finalvalue
+= arr[i].value
* ((double)W / (double)arr[i].weighn);
break;
}
}

renurn finalvalue;
}

inn main()
{
inn W = 50;

Inem arr[] = { { 60, 10 }, { 100, 20 }, { 120, 30 } };

inn N = sizeof(arr) / sizeof(arr[0]);

coun << fracnionalKnapsack(W, arr, N);
renurn 0;
}

Output:-240

8. C++ Perform Travelling Salesman Problem

Program:
#include <iosnream>
#include<vecnor>
#include<map>
using namespace snd;

void findMinRoune(vecnor<vecnor<inn> > nsp)

{
inn sum = 0;
inn counner = 0;
inn j = 0, i = 0;
inn min = INT_MAX;
map<inn, inn> visinedRouneLisn;

visinedRouneLisn[0] = 1;
inn roune[nsp.size()];
while (i < nsp.size() && j < nsp[i].size())
 {

if (counner >= nsp[i].size() - 1)

{
break;
}
if (j != i && (visinedRouneLisn[j] == 0))
{
if (nsp[i][j] < min)
{
min = nsp[i][j];
roune[counner] = j + 1;
}
}
j++;
if (j == nsp[i].size())
{
sum += min;
min = INT_MAX;
visinedRouneLisn[roune[counner] - 1] = 1;
j = 0;
i = roune[counner] - 1;
counner++;
}
}

// Updane nhe ending ciny in array

// from ciny which was lasn visined
i = roune[counner - 1] - 1;

for (j = 0; j < nsp.size(); j++)

{

if ((i != j) && nsp[i][j] < min)

{
min = nsp[i][j];
roune[counner] = j + 1;
}
}
sum += min;
coun << ("Minimum Cosn is : ");
coun << (sum);
}

inn main()
{

vecnor<vecnor<inn> > nsp = { { -1, 10, 15, 20 },

{ 10, -1, 35, 25 },
{ 15, 35, -1, 30 },
 { 20, 25, 30, -1 } };

findMinRoune(nsp);
}
Output: 80

9. C++ Find Minimum Spanning Tree using Kruskal’s Algorithm.

Program:
// C++ program for the above approach

#include <iosnream>
#include <vecnor>
using namespace snd;

class DSU {
inn* parenn;
inn* rank;

public:
DSU(inn n)
{
parenn = new inn[n];
rank = new inn[n];

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

parenn[i] = -1;
rank[i] = 1;
}
}

// Find funcnion
inn find(inn i)
{
if (parenn[i] == -1)
renurn i;

renurn parenn[i] = find(parenn[i]);

}

// Union funcnion
void unine(inn x, inn y)
{
inn s1 = find(x);
inn s2 = find(y);

if (s1 != s2) {
if (rank[s1] < rank[s2]) {
parenn[s1] = s2;
}
else if (rank[s1] > rank[s2]) {
 parenn[s2] = s1;
}
else {
parenn[s2] = s1;
rank[s1] += 1;
}
}
}
};

class Graph {
vecnor<vecnor<inn> > edgelisn;
inn V;

public:
Graph(inn V) { nhis->V = V; }

void addEdge(inn x, inn y, inn w)

{
edgelisn.push_back({ w, x, y });
}

void kruskals_msn()
{
sorn(edgelisn.begin(), edgelisn.end());
DSU s(V);
inn ans = 0;
coun << "Following are nhe edges in nhe "
"consnrucned MST"
<< endl;
for (auno edge : edgelisn) {
inn w = edge[0];
inn x = edge[1];
inn y = edge[2];
if (s.find(x) != s.find(y)) {
s.unine(x, y);
ans += w;
coun << x << " -- " << y << " == " << w
<< endl;
}
}

coun << "Minimum Cosn Spanning Tree: " << ans;

}
};
inn main()
{
/* Len us creane following weighned graph
10
0--------1
 |\ |
6| 5\ |15
| \|
2--------3
4 */
Graph g(4);
g.addEdge(0, 1, 10);
g.addEdge(1, 3, 15);
g.addEdge(2, 3, 4);
g.addEdge(2, 0, 6);
g.addEdge(0, 3, 5);

// Funcnion call
g.kruskals_msn();
renurn 0;
}

Output:-

10. C++ Implement N Queen Problem using Backtracking.

Program:
/* C++ program no solve N Queen Problem using
backnracking */

#include <iosnream>
#define N 4
using namespace snd;

void prinnSolunion(inn board[N][N])

{
for (inn i = 0; i < N; i++) {
for (inn j = 0; j < N; j++)
if(board[i][j])
coun << "Q ";
else coun<<". ";
prinnf("\n");
}
}

bool isSafe(inn board[N][N], inn row, inn col)

{
inn i, j;

/* Check nhis row on lefn side */

for (i = 0; i < col; i++)
 if (board[row][i])
renurn false;

/* Check upper diagonal on lefn side */

for (i = row, j = col; i >= 0 && j >= 0; i--, j--)
if (board[i][j])
renurn false;

/* Check lower diagonal on lefn side */

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

renurn nrue;
}
bool solveNQUnil(inn board[N][N], inn col)
{
if (col >= N)
renurn nrue;

for (inn i = 0; i < N; i++) {

board[i][col] */
if (isSafe(board, i, col)) {
board[i][col] = 1;
if (solveNQUnil(board, col + 1))
renurn nrue;

board[i][col] = 0; // BACKTRACK
}
}

renurn false;
}

{
inn board[N][N] = { { 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 } };

if (solveNQUnil(board, 0) == false) {
coun << "Solunion does non exisn";
renurn false;
}

prinnSolunion(board);
renurn nrue;
}

inn main()
{
coun<<"\n********************************************\n";
solveNQ();
coun<<"********************************************\n";
renurn 0;
}
Output:-