Tarviha Fatima

15L-4204
Section: A

Data Structures - Assignment 4

1) Find Min

int find_min(int *arr, int size, int min)

{
if (size == 0)
{
return min;
}
else
{
if (arr[size-1] < min)
{
min = arr[size - 1];
}
find_min(arr, size-1, min);
}
}

Recurrence Relation:

T(n) = {1 T(n-1) + 1}

Big-Oh:

T(n) = T(n-2) + 2
T(n) = T(n-3) + 3
If k;
T(n) = T(n-k) + k

Now, T(1) = 1
T(n-k) = 1
n k = 1
k = n 1
T(n) = 1 + n 1

T(n) = n T(n) = O(n)

2) Reverse Digits:

int calculate_Power(int base, int power_given)

{
if (power_given == 1)
return 1;
else
return (base*calculate_Power(base, power_given - 1));
}

int reverseDigits(int n, int &power)

{
if (n > 0)
{
int x = n % 10;
x *= calculate_Power(10, power);
n = n / 10;
power -= 1;
x += reverseDigits(n, power);
return x;
}
else
return 0;
}

Recurrence Relation:

T(n) = {1 T(n/10) + n}

Big-Oh:

T(n) = T(n/102) + 2n
T(n) = T(n/103) + 3n
If k;
T(n) = T(n/10k) + kn

Now, T(1) = 1
T(n/10k) = 1
n / 10k = 1
k = log10(n)
T(n) = 1 + nlog10(n)

T(n) = 1 + nlog10(n) T(n) = O(nlog(n))

3) Sum of Digits

int sumOfDigits(int n)
{
if (n == 0)
{
return 0;
}
int x = n % 10;
n = n / 10;
x += sumOfDigits(n);
}

Recurrence Relation:

T(n) = {1 T(n/10) + 1}

Big-Oh:

T(n) = T(n/102) + 2
T(n) = T(n/103) + 3
If k;
T(n) = T(n/10k) + k

Now, T(1) = 1
T(n/10k) = 1
n / 10k = 1
k = log10(n)
T(n) = 1 + log10(n)

T(n) = 1 + log10(n) T(n) = O(log(n))

4) Palindrome

bool isPalindrome(char * str, int len)

{
if (len <= (strlen(str) - len))
{
return true;
}
else if (str[len - 1] == str[strlen(str) - len])
{
 isPalindrome(str, len - 1);
}
else
return false;
}

Recurrence Relation:

T(n) = {1 T(n-1) + 1}

Big-Oh:

T(n) = T(n-2) + 2
T(n) = T(n-3) + 3
If k;
T(n) = T(n-k) + k

Now, T(1) = 1
T(n-k) = 1
n k = 1
k = n 1
T(n) = 1 + n 1

T(n) = n T(n) = O(n)

5) Count Paths

int countPaths(int n, int m)

{
if (n == 0 && m == 0)
{
return 0;
}
else if (n == 0 || m == 0)
{
return 1;
}
else
{
int x = countPaths(n, m - 1);
x = x + countPaths(n - 1, m);
return x;
}
}

Recurrence Relation:
T(n) = {1 2T(n-1) + 1}

Big-Oh:

T(n) = 22T(n-2) + 2
T(n) = 23T(n-3) + 3
If k;
T(n) = 2kT(n-k) + k

Now, T(1) = 1
T(n-k) = 1
n k = 1
k = n 1
T(n) = 2n-1 + n - 1

T(n) = 2n-1 + n 1 T(n) = O(2n)

6) Binary Search

bool binary_search(int *arr, int find, int low, int high)

{
if (high - low <= 1)
{
if (find == arr[low] || find == arr[high])
{
return true;
}
else
{
return false;
}
}
else
{
int mid = (low + high) / 2;
if (find == arr[mid])
{
return true;
}
else if (find < arr[mid])
{
high = mid;
}
else
{
low = mid;
}
 binary_search(arr, find, low, high);
}
}

Recurrence Relation:

T(n) = {1 T(n/2) + 1}

Big-Oh:

T(n) = T(n/22) + 2
T(n) = T(n/23) + 3
If k;
T(n) = T(n/2k) + k

Now, T(1) = 1
T(n/2k) = 1
n / 2k = 1
k = log2(n)
T(n) = 1 + log2(n)

T(n) = 1 + log2(n) T(n) = O(log(n))

7) Tower of Hanoi

void hanoi(int from, int to, int temp, int num)

{
if (num <= 1)
{
cout << "Disk " << num << " moved from " << from << " to " << to << endl;
}
else
{
hanoi(from, temp, to, num - 1);
cout << "Disk " << num << " moved from " << from << " to " << to << endl;
hanoi(temp, to, from, num - 1);
}
}

Recurrence Relation:
T(n) = {1 2T(n-1) + 1}

Big-Oh:

T(n) = 22T(n-2) + 2
T(n) = 23T(n-3) + 3
If k;
T(n) = 2kT(n-k) + k

Now, T(1) = 1
T(n-k) = 1
n k = 1
k = n 1
T(n) = 2n-1 + n - 1

T(n) = 2n-1 + n 1 T(n) = O(2n)

8) Merge Sort

void merge(int arr[], int low, int mid, int high)

{
int *left = new int[mid - low + 2];
int *right = new int[high - mid + 1];

for (int i = 1; i <= mid - low + 1; i++)

{
left[i] = arr[low + i - 1];
}

for (int j = 1; j <= high - mid; j++)

{
right[j] = arr[mid + j];
}

left[mid - low + 1 + 1] = 999;

right[high - mid + 1] = 999;

int i = 1, j = 1;
for (int k = low; k <= high; k++)
{
if (left[i] <= right[j])
{
arr[k] = left[i];
i++;
}
else
{
arr[k] = right[j];
 j++;
}
}
}

void MergeSort(int arr[], int low, int high)

{
if (low < high)
{
int mid = (low + high) / 2;
MergeSort(arr, low, mid);
MergeSort(arr, mid + 1, high);
merge(arr, low, mid, high);
}
}

void main()
{
int size;
cout << "Enter the size of the array" << endl;
cin >> size;
int *arr = new int[size];

cout << "Enter the elements in the array" << endl;

for (int i = 1;i <= size;i++)
{
cout << i << ": ";
cin >> arr[i];
cout << endl;
}

MergeSort(arr, 1, size);

cout << "After Merge Sort: " << endl;

for (int i = 1; i <= size;i++)
{
cout << arr[i] << endl;
}
system("pause");
}

Recurrence Relation:

T(n) = {1 2T(n/2) + n}

Big-Oh:

T(n) = 22T(n/22) + 2n
T(n) = 23(n/23) + 3n
If k;
T(n) = 2kT(n/2k) + k*n
Now, T(1) = 1
T(n/2k) = 1
n / 2k = 1
k = log2(n)
T(n) = n + n*log2(n)

T(n) = n + n*log2(n) T(n) = O(n*log(n))

9) Eight Queens

int n = 1;

bool queens(int t[], int row, int col)

{
for (int i = 0; i < col; i++)
{
if (t[i] == row || t[i] == row - (col - i) || t[i] == row + (col -
i))
{
return false;
}
}
return true;
}

void print(int t[])

{
cout << n << ": ";
for (int i = 0; i < 8; i++)
{
cout << " " << t[i];
}
cout << endl;
n++;
}

void check(int t[], int k)

{
if (k == 8)
{
print(t);
}
else
{
for (int i = 0; i < 8; i++)
{
if (queens(t, i, k))
{
t[k] = i;
check(t, k + 1);
}
}
 }
}

void main()
{
int SIZE = 8;
int *t = new int [SIZE];
cout << "Possible Solutions:\n\n";
cout << " a b c d e f g h\n\n";
check(t, 0);
system("pause");
}

Recurrence Relation:

T(n) = {1 T(n-1) + 1}

Big-Oh:

T(n) = T(n-2) + 2
T(n) = T(n-3) + 3
If k;
T(n) = T(n-k) + k

Now, T(1) = 1
T(n-k) = 1
n k = 1
k = n 1
T(n) = 1 + n 1

T(n) = n T(n) = O(n)

10) Find Subsets

vector<int> temp;
vector< vector<int> > stack;

void subset(int arr[], int k, int n, int curr)

{
if (curr == n)
return;

if (k == 1)
{
for (int i = curr; i<n; i++)
 {
temp.push_back(arr[i]);
stack.push_back(temp);
temp.pop_back();
}
}

for (int j = curr; j<n; j++)

{
temp.push_back(arr[j]);
subset(arr, k - 1, n, j + 1);
temp.pop_back();
}
}

long int fact(int x) //defining the function or function definition

{
int i, f = 1;
for (i = 2; i <= x; i++)
{
f = f*i;
}
return f;
}

int ** computeSubsets(int n, int k, int arr[])

{
int **result; // 2d dynamic array
long int ncr, npr;
int r = k;

npr = fact(n) / fact(n - r);

ncr = npr / fact(r);
result = new int *[ncr]; // n C r

for (int i = 0; i < ncr; i++)

{
result[i] = new int[k];
}

// call recursive function

subset(arr, k, n, 0);

for (int i = 0; i < ncr; i++)

{
for (int j = 0; j < k; j++)
{
result[i][j] = stack[i][j];
}
}

return result;
}

int main()
{
int arr[] = { 1,2,3,4,5 };
int k = 3;
 int n = sizeof(arr) / sizeof(arr[0]);

int ** r = computeSubsets(n, k, arr);

int npr = fact(n) / fact(n - k);
// calling the function or function calling
int ncr = npr / fact(k); //function calling
cout << "The required subsets are:\n\n";
for (int i = 0; i < ncr; i++)
{
for (int j = 0; j < k; j++)
{
cout << r[i][j] << ' ';
}
cout << endl;
}

_getch();
}

Recurrence Relation:

T(n) = {1 T(n-1) + n}

Big-Oh:

T(n) = T(n-2) + 2n
T(n) = T(n-3) + 3n
If k;
T(n) = T(n-k) + kn

Now, T(1) = 1
T(n-k) = 1
n k = 1
k = n 1
T(n) = 1 + (n 1)(n)

T(n) = n2 n + 1 T(n) = O(n2)