Question

Hello, IN C++ please help creating a 100% functional program that follows all the guidelines shown below. (I WILL RATE, NO INCOMPLETE OR OTHER PEOPLE'S SOLUTIONS PLEASE):

THANK YOU.

a. Randomly generate three integer arrays A1, A2, and A3 of sizes N=103 , 105 , and 107 (or 106 , if your computer cannot handle an integer array of size 107 ), in that order.

b. Run all the four sorting algorithms (insertion, merge, heap and quick sort) we’ve learned in class on each of the three arrays A1, A2 and A3, and record the number of comparisons between array elements and actual elapsed times in appropriate time units, for instance, milliseconds.

c. Repeat b on the sorted arrays A1, A2 and A3.

d. Reverse the order of the three arrays A1, A2 and A3 and repeat b once more.  

e. Include a table to summarize the results from the benchmarking steps as described above. Also, include some discussion about whether the performance of the four sorting algorithms as demonstrated by your program are consistent with the known theoretical analysis results, worst‐, best and average‐cases, if available.

Answer 1

#include <iostream>

#include <time.h>

#include<cstdlib>

#include<cmath>

#include <algorithm>

using namespace std;

int InsertionSort(int[], int);

int MergeSort(int[], int, int);

int HeapSort(int[], int);

int QuickSort(int[], int, int);

int MERGE(int[], int, int, int);

int PARTITION(int[], int, int,int*);

int MAX_HEAPIFY(int[], int, int);

int BUILD_MAX_HEAP(int[], int);

int main()

{

int RandomArray1[100];

int RandomArray2[10000];

int RandomArray3[100000];

srand((unsigned)time(0));

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

{

RandomArray1[i] = rand();

}

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

{

RandomArray2[i] = rand();

}

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

{

RandomArray3[i] = rand();

}

int c1,c2,c3,c4;

clock_t start;

start =clock();

c1=InsertionSort(RandomArray1, 100);

double time1 = (double)(clock()-start)/CLOCKS_PER_SEC;

start =clock();

c2=QuickSort(RandomArray1, 0, 99);

double time2 = (double)(clock()-start)/CLOCKS_PER_SEC;

start =clock();

c3=MergeSort(RandomArray1, 0, 99);

double time3 = (double)(clock()-start)/CLOCKS_PER_SEC;

start =clock();

c4=HeapSort(RandomArray1, 99);

double time4 = (double)(clock()-start)/CLOCKS_PER_SEC;

cout<<"Time taken by sortings :"<<time1<<" \n"<<time2<<" \n"<<time3<<" \n"<<time4<<endl;

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

{

cout << i << " " << RandomArray1[i] << endl;

}

return 0;

}

int InsertionSort(int arr[], int n)

{

int c=0;
int i, key, j;

for (j = 2; j < n; j++)

{

key = arr[j];

i = j - 1;

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

{

c++;

arr[i + 1] = arr[i];

i = i - 1;

}

arr[i + 1] = key;

}

return c;

}

int MergeSort(int arr[], int p, int r)

{

int c=0;

int q;

if (p < r)

{

q = (p + r) / 2;

MergeSort(arr, p, q);

MergeSort(arr, q + 1, r);

c=c+MERGE(arr, p, q, r);

}

return c;

}

int MERGE(int arr[], int p, int q, int r)

{

int c=0;
int* Larray;

int* Rarray;

int n1 = q - p + 1;

int n2 = r - q;

int i, j;

Larray = new int[n1];

Rarray = new int[n2];

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

Larray[i] = arr[p + i];

for (int j = 0; j < n2; j++)

Rarray[j] = arr[q + j + 1];

i = 0;

j = 0;

int k = p;

for (; i < n1 && j<n2;)

{

if (Larray[i] <= Rarray[j])

{

c++;;//updating comparisions

arr[k] = Larray[i];

i = i + 1;

}

else {

arr[k] = Rarray[j];

j = j + 1;

}

k++;

}

while (i < n1) {

arr[k] = Larray[i];

i++;

k++;

}

while (j < n2) {

arr[k] = Rarray[j];

j++;

k++;

}

return c;

}

int HeapSort(int arr[], int n)

{

int c=0;

c=c+BUILD_MAX_HEAP(arr, n);

for (int i = n-1; i >= 0; i--)

{

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

c=c+MAX_HEAPIFY(arr, i, 0);

}

return c;

}

int BUILD_MAX_HEAP(int arr[], int n)

{

int c=0;

for (int i = (n/2) -1; i >=0; i--)

c=c+MAX_HEAPIFY(arr, n, i);

return c;

}

int MAX_HEAPIFY(int arr[], int n, int i)

{

int c=0;

int left = 2 * i + 1;

int right = 2 * i + 2;

int largest = i;

if (left < n && arr[left] > arr[largest])

{

c++;

largest = left;

}

if (right < n && arr[right] > arr[largest])

{

c++;

largest = right;

}

if (largest != i)

{

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

c=c+MAX_HEAPIFY(arr, n, largest);

}

return c;

}

int QuickSort(int arr[], int p, int r)

{

int c=0;

int q;

if (p < r)

{

q = PARTITION(arr, p, r,&c);

QuickSort(arr, p, q - 1);

QuickSort(arr, q + 1, r);

}

return c;

}

int PARTITION(int arr[], int p, int r,int *c)

{

int x = arr[r];

int i = p - 1;

for (int j = p; j <= (r - 1); j++)

{

if (arr[j] <= x)

{

(*c)=(*c)+1;

i = i + 1;

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

}

}

swap(arr[i + 1], arr[r]);

return (i + 1);

}