Add a counter to the functions insertionSort and mergeSort that counts the number of comparisons that are made. Run the two functions with arrays of various sizes.
At what size does the difference in the number of comparisons become significant?
How does this size compare with the size that the orders of these algorithms predict?

#include <iostream>

#include <string>

#include <ctime>

using namespace std;

void insertionSort(int *arr, int size);

void mergeSort(int *items, int size);

void merge(int *temp1, int *temp2, int *items, int p, int q, int size);

void copyArray(int *sour, int sstart, int size, int *dest, int dstart, int n);

void printArray(int *arr, int size);

int insertionSortComparisons = 0;

int mergeSortComparisons = 0;

int main()

{

srand(time(NULL));

int size = 0;

cout << "Size\tinsertionSort\tmergeSort" << endl;

for(int i = 1; i <= 20; i++)

{

size = size + 5;

insertionSortComparisons = 0;

mergeSortComparisons = 0;

int *arr1 = new int[size];

int *arr2 = new int[size];

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

{

int number = 1 + rand() % 100;

arr1[i] = number;

arr2[i] = number;

}

insertionSort(arr1, size);

mergeSort(arr2, size);

cout << size << "\t\t" << insertionSortComparisons << "\t" << mergeSortComparisons << endl;

}

system("pause");

return 0;

}

void insertionSort(int arr[], int size)

{

for(int i = 1; i < size; i++)

{

int temp = arr[i];

int j = i;

insertionSortComparisons++;

while(j > 0 && temp < arr[j - 1])

{

arr[j] = arr[j - 1];

j--;

}

arr[j] = temp;

}

}

void mergeSort(int items[], int size)

{

int s1 = size / 2;

int s2 = size - s1;

int *temp1 = new int[s1];

int *temp2 = new int[s2];

if(size > 1)

{

copyArray(items, 0, size, temp1, 0, s1);

copyArray(items, s1, size, temp2, 0, s2);

mergeSort(temp1, s1);

mergeSort(temp2, s2);

merge(temp1, temp2, items, s1, s2, size);

}

}

void merge(int temp1[], int temp2[], int items[], int p, int q, int size)

{

int i = 0;

int j = 0;

int k = 0;

while(i < p && j < q)

{

mergeSortComparisons++;

if(temp1[i] <= temp2[j])

{

items[k] = temp1[i];

i = i + 1;

}

else

{

items[k] = temp2[j];

j = j + 1;

}

k = k + 1;

}

if(i == p)

copyArray(temp2, j, size, items, k, q - j);

else

copyArray(temp1, i, size, items, k, p - i);

}

void copyArray(int sour[], int sstart, int size, int dest[], int dstart, int n)

{

for(int i = sstart, j = dstart; i < size; i++, j++)

{

dest[j] = sour[i];

}

}

void printArray(int *arr, int size)

{

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

{

cout << arr[i] << " ";

}

cout << endl;

}

Explanation:

This program is a c++ program.

The c++ add a counter to the functions insertionSort and mergeSort that counts the number of comparisons that are made.

It Run the two functions with arrays of various sizes.

It also derermines the size that does the difference in the number of comparisons and how it become significant. Also talks How does this size compare with the size that the orders of these algorithms predict.

From the sample output in attachment, the difference between the number of comparisons of the insertionSort and the mergeSort techniques is increasing with the size of the array.

See attachment for sample output.

c

explanation:

the answers

1. video

2. net

3. cloud

4. optical

5. rambus

hope it