Question

Programming: Programmatically generate three type of arrays (or vectors) of size 10,000: an array that is sorted in ascending order, a reversed array (an array that is sorted in descending order), and a random array. • Programmatically sort the three arrays using bubble sort, selection sort, insertion sort, shell sort, merge sort, and quick sort (the regular one and the improved one ) algorithms. For each sorting algorithm, calculate the number of exchanges (or shifts) and the number of comparisons for these sorting algorithms. Summarize the result in tables (see below). • Discuss whether your results match the big O of these algorithms. • Note: you can use the sorting algorithms on Blackboard. For quick sort, the improved one is called "middle_quick_sort".

Answer 1

#include<stdio.h>

#include<time.h>

#include<stdlib.h>

int MAX_VAL = 65536;

int compares; // total number of comparisons

int moves; // total number of moves

int compare(int comparison) {

compares++;

return comparison;

}

void initStats() {

compares = 0;

moves = 0;

}

void move(int *arr, int dest, int source) {

moves++;

arr[dest] = arr[source];

}

void swap(int *arr, int a, int b) {

int temp = arr[a];

arr[a] = arr[b];

arr[b] = temp;

moves += 3;

}

/**

* randomArray - creates an array of randomly generated integers

* with the specified number of elements and the specified

* maximum value

*/

int *randomArray(int n, int maxVal) {

int *arr = (int *)malloc(n*sizeof(int));

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

arr[i] = rand()%100;

}

return arr;

}

/*

* indexSmallest - returns the index of the smallest element

* in the subarray from arr[lower] to arr[upper]. Used by

* selectionSort.

*/

int indexSmallest(int *arr, int lower, int upper) {

int indexMin = lower;

for (int i = lower + 1; i <= upper; i++)

if (compare(arr[i] < arr[indexMin]))

indexMin = i;

return indexMin;

}

/** selectionSort */

void selectionSort(int *arr, int n) {

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

int j = indexSmallest(arr, i, n - 1);

swap(arr, i, j);

}

}

/** insertionSort */

void insertionSort(int *arr, int n) {

for (int i = 1; i < n; i++) {

if (compare(arr[i] < arr[i-1])) {

int toInsert = arr[i];

moves++;

int j = i;

do {

move(arr, j, j - 1);

j = j - 1;

} while (j > 0 && compare(toInsert < arr[j-1]));

arr[j] = toInsert;

moves++;

}

}

}

/** bubbleSort */

void bubbleSort(int *arr, int n) {

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

for (int j = 0; j < i; j++) {

if (compare(arr[j] > arr[j+1]))

swap(arr, j, j+1);

}

}

}

/*

* A helper method for qSort that takes the array that begins with

* element arr[first] and ends with element arr[last] and

* partitions it into two subarrays using the middle element of

* the array for the pivot. It returns the index of the last

* element of the left subarray formed by the partition. All

* elements in the left subarray are <= the pivot, and all

* elements in the right subarray are >= the pivot.

*/

int partition(int *arr, int first, int last) {

int pivot = arr[(first + last)/2];

moves++; // for the above assignment

int i = first - 1; // index going left to right

int j = last + 1; // index going right to left

while (1) {

// Moving from left to right, find an element >= the pivot.

do {

i++;

} while (compare(arr[i] < pivot));

// Moving from right to left, find an element <= the pivot.

do {

j--;

} while (compare(arr[j] > pivot));

// Swap the elements so that they end up in the correct

// subarray, or quit if the indices have overlapped or crossed.

if (i < j)

swap(arr, i, j);

else

return j; // index of last element in the left subarray

}

}

/*

* A recursive helper method that actually implements quicksort.

* The initial recursive call is made by quicksort() -- see below.

*/

void qSort(int *arr, int first, int last) {

// Partition the array. split is the index of the last

// element of the left subarray formed by the partition.

int split = partition(arr, first, last);

//

// Note that we only make recursive calls on subarrays that

// have two or more elements, and thus the base case is when

// neither subarray has two or more elements.

//

if (first < split)

qSort(arr, first, split); // left subarray

if (last > split + 1)

qSort(arr, split + 1, last); // right subarray

}

/** quickSort */

void quickSort(int *arr, int n) {

qSort(arr, 0, n - 1);

}

void printArray(int *arr, int n) {

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

printf("%d ", arr[i]);

}

void printStats() {

printf("%d comparisons\n ",compares);

}

int main()

{

srand(time(NULL));

int *a = randomArray(10,100);

printf("Original Array: \n");

printArray(a, 10);

printf("\n\ninsertionSort\t\t");

initStats();

insertionSort(a,10);

printStats();

printArray(a, 10);

printf("\n\nselectionSort\t\t");

initStats();

selectionSort(a,10);

printStats();

printArray(a, 10);

printf("\n\nbubbleSort\t\t");

initStats();

bubbleSort(a,10);

printStats();

printArray(a, 10);

printf("\n\nQuickSort\t\t");

initStats();

quickSort(a,10);

printStats();

printArray(a, 10);

}

============================================================
See output



Thanks, PLEASE COMMENT if there is any concern. You can increase the size and it will work ( I showed it for 10 elements)