Lab 7 (50 pts) Due Sunday, May 20)

Transcription

1 Lab 7 (50 pts) Due Sunday, May 20) For this lab, you will be comparing sorting algorithms, specifically the speed of selection, insertion, quick, and merge sort on random, in-order, and reverse-order lists of different sizes. I am giving you the SortingClass.hpp (although you should know how to create a header file!!!) file and an outline of the SortingClass.cpp file, with the time library included so we can use the clock object to get the current time in clock ticks (so it will be dependent on the clock speed of your processor). You will be filling in the.cpp file, including the constructors, which will make 3 arrays: one of random numbers, one of numbers in order, and one of reverse-order numbers. The random numbers should all be random between the smallest and largest field. The in-order array numbers should start at the smallest field and build up. The reverse-order numbers should start at the largest and work backwards. You will also need to write a copyarray method, which will take as an input parameter a string. The string indicates whether the array to be copied is the random array, the in-order one, or the reverse order one. This method must dynamically allocate a new array, copy the old array to the new array, and then return the address of the first value of this new array. The reason this method must exist is that after we run the first sorting algorithm on all of the three arrays, all three arrays will be sorted. If you want to then accurately compare the speed of another sorting algorithm on the same arrays, we can t sort the original arrays. We must sort copies of the arrays. Because the sorting methods are all over the internet, make sure you thoroughly comment the code (i.e., explain what the sort is doing at each part of the sort). As stated in the last lab, your code MUST compile before you turn it in. Here is the SortingClass.hpp: #ifndef SORTINGCLASS_HPP_ #define SORTINGCLASS_HPP_ #include <string> using namespace std; class SortingClass { int *randarr; int *inorderarr; int *revorderarr; int size; int smallest; int largest; public: SortingClass(int si, int sm, int la); SortingClass(int si); SortingClass(); int *copyarr(string s); // takes the word "random", "inorder", or "reverse order" as input,

2 // and returns the address of a newly made copy of that array // because we don't want to mess with the original arrays for the other sorts void selectionsort(int arr[]); // must take array as input because you want to pass in a // copy of either the in-order, reverse-order, or random array and sort it void insertionsort(int arr[]); void quicksort(int first, int last, int arr[]); // first and last are the indices indicating // the current part of the array you're sorting int partition(int first, int last, int arr[]); //again, because you're only partitioning // part of the array void merge(int arr[], int f, int m, int l); // in this case, you're creating a newly //merges list from 2 portions of the array that are already sorted, and then copying the //sorted portion back into the list. Thus you'll need to know the index of the beginning of //the first sorted list, the index of the beginning of the second sorted list (m), and the //index of the last value in the second sorted list void mergesort(int arr[], int low, int hi); // this is the part that divides the array into //smaller and smaller subarrays. The stopping condition is when the low is >= to the hi index //in the array void comparesorts(); // the function that should be called from main after you've // created a SortingClass object. This function compares the timing of the //different sorting methods when the arrays are in order, in reverse order, and random. ; #endif /* SORTINGCLASS_HPP_ */ /***********************************************************************************/ And here is the outline of the SortingClass.cpp: #include "SortingClass.hpp" #include <ctime> #include <cstdlib> #include <string> #include <iostream> #include <ctime> using namespace std; SortingClass::SortingClass(int si, int sm, int la){ //(5 pts) random numbers should be between the smallest and largest numbers, //in-order should start at smallest //reverse order should start at largest //all should be of size size

3 SortingClass::SortingClass(int si){ //(2 pts) largest should be 5000, smallest should be 10 SortingClass::SortingClass(){ // (2 pts)start with a smaller size to make sure your sorting algorithms are working // and build up to int *SortingClass::copyArr(string s) { //(7 pts) based on s (which can be rev, ord, or rand, creates a new array, // copies over the old array, and returns the address of the new array void SortingClass::selectionSort(int arr[]) { // (4 pts) Does what you d think to the array passed into the method. void SortingClass::insertionSort(int arr[]){ // (4 pts) Does what you think to the array passed into the method. void SortingClass::quickSort(int first, int last, int arr[]){ // (4 pts) first and last are the indices indicating // the current part of the array you're sorting int SortingClass::partition(int first, int last, int arr[]){ //(7 pts)again, because you're only partitioning part of the array void SortingClass::merge(int arr[], int f, int m, int l){ // (7 pts)f is first index, m is middle index (end of first sorted array portion) // and l is the last index of the second array portion void SortingClass::mergeSort(int arr[], int low, int hi) { // (4 pts)keeps dividing the portion of the array between the low index and the hi // index by dividing by 2 void SortingClass::compareSorts() { clock_t double timepassed; //SELECTION SORT int *arr = copyarr("rand"); selectionsort(arr); cout << "Selection: rand "<<timepassed << endl;

4 arr = copyarr("rev"); selectionsort(arr); cout << "Selection: rev "<<timepassed << endl; selectionsort(arr); cout << "Selection: ord "<<timepassed << endl; //INSERTION arr = copyarr("rand"); insertionsort(arr); cout << "Insertion: rand "<<timepassed << endl; arr = copyarr("rev"); insertionsort(arr); cout << "Insertion: rev "<<timepassed << endl; insertionsort(arr);

5 cout << "Insertion: ord "<<timepassed << endl; //QUICKSORT arr = copyarr("rand"); quicksort(0,size,arr); cout << "Quick: rand "<<timepassed << endl; arr = copyarr("rev"); quicksort(0,size,arr); cout << "Quick: rev "<<timepassed << endl; quicksort(0,size,arr); cout << "Quick: ord "<<timepassed << endl; //MERGE arr = copyarr("rand"); mergesort(arr,0,size-1); cout << "Merge: rand "<<timepassed << endl; arr = copyarr("rev"); mergesort(arr,0,size-1);

6 cout << "Merge: rev "<<timepassed << endl; mergesort(arr,0,size-1); cout << "Merge: ord "<<timepassed << endl; /*************************************************************************/ (4 pts) You must also write the main function, which creates an object of type SortingClass, and then calls the comparesorts method. EXTRA CREDIT: (5 pts) Add bubblesort to the header file, the source code, and the comparesorts method. Comment it thoroughly so that you re explaining what is going on (5 pts) Add heapsort to the header file, the source code, and the comparesorts method. Comment it thoroughly (10 pts) Add a radixsort to the header file, the source code, and the comparesorts method. Comment it thoroughly.