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.

answer:

note: microsoft word you make columns easier and faster. you can customize how your columns look and design their layout. you can use breaks and much more.

explanation: you can also look it up. to see.

given the options, i would say your best bet is c. the modem supports up to 56 kbps, which is too low for video streaming. dial up modems use actual phone lines, which only can go up to 56 kbps as that's more than sufficient for traditional phone calls. this is also the reason why when a dial-up modem connects, you hear all those sounds. it's literally using the phone line to establish a connection.