CMPE 180A Data Structures and Algorithms in C++ Spring 2018 Instructor: Ron Mak

Transcription

1 San José State University Department of Computer Engineering CMPE 180A Data Structures and Algorithms in C++ Spring 2018 Instructor: Ron Mak Assignment # points Assigned: Saturday, April 21 Due: Thursday, April 26 at 5:30 PM URL: Canvas: Assignment 12. Sorting algorithms Points: 210 Sorting algorithms This assignment will give you practice coding several important sorting algorithms, and you will be able to compare their performances while sorting data of various sizes. You will sort data elements in vectors with the selection sort, insertion short, Shellsort, and quicksort algorithms, and sort data elements in a linked list with the mergesort algorithm. There will be two versions of Shellsort, a suboptimal version that uses the halving technique for the diminishing increment, and an optimal version that uses a formula suggested by famous computer scientist Don Knuth. There will also be two versions of quicksort, a suboptimal version that uses a bad pivoting strategy, and an optimal version that uses a good pivoting strategy. You are provided the code for the selection sort algorithm as an example, and you will code all versions of the other algorithms. You are also provided much of the support code. Class hierarchy The UML (Unified Modeling Language) class diagram on the following page shows the class hierarchy. The code you will write are in classes InsertionSort, ShellSortSuboptimal, ShellSortOptimal, QuickSorter, QuickSortSuboptimal QuickSortOptimal, LinkedList, and MergeSort. Complete class SelectionSort is provided as an example. These sorting algorithms are all described in Chapter 10 of the Malik textbook. You can also find many sorting tutorials on the Web. 1

2 Class Element Your program will sort Element data, both in vectors and in linked lists. Each element has a long value. Your program must also keep track of how many times each copy constructor and destructor is called. Abstract class Sorter Class Sorter is the base class of all the sorting algorithms. Its member function sort() calls member function run_sort_algorithm() which is defined in the sorting subclasses that you will write. Function run_sort_algorithm() is abstract, and therefore also the class itself is abstract. Vector sorting classes The sorting classes SelectionSort, InsertionSort, ShellSortSuboptimal, and ShellSortOptimal each defines the member function run_sort_algorithm(). This member function is where you code each sorting algorithm. 2

3 For class ShellSortSuboptimal, use the halving technique for the diminishing increment. The value of the interval h for the first pass should be half the data size. For each subsequent pass, half the increment, until the increment is just 1. For class ShellSortOptimal, use Knuth s formula 3i +1 for i = 0, 1, 2, 3,... in reverse for the diminishing increment. For example:..., 121, 40, 13, 4, 1. Abstract class QuickSorter Abstract class QuickSorter does most of the work of the recursive quicksort algorithm. Its member function choose_pivot() calls abstract member function choose_pivot_strategy(). The latter is defined by the two subclasses, QuickSortSuboptimal and QuickSortOptimal. In subclass QuickSortSuboptimal, member function choose_pivot_strategy() should always return the leftmost value of the subrange as the bad pivot value to use to partition the subrange. In subclass QuickSortOptimal, member function choose_pivot_strategy() should always return the median of three value of the subrange as the good pivot value. Look at the values at the left and right ends of the subrange and the value in the middle, and choose the value that is between the other two. Subclass MergeSort Unlike the other sorting subclasses, subclass MergeSort sorts a singly linked list. Given a list to sort, it splits the list into two sublists. It recursively sorts the two sublists, and then it merges the two sublists back together. Merging involves repeatedly adding the head node of either sublist back to the main list. Which sublist donates its head depends on which head node has the smaller value. When one sublist is exhausted, concatenate the remaining nodes of the other sublist to the end of the main list. When done properly, mergesort does not require any copying of data values. It does all of its work by relinking the nodes to move them from one list to another. Class LinkedList Class LinkedList manages a singly linked list. Member function split() splits the list into two sublists of the same size, plus or minus one. Member function concatenate() appends another list to the end of the list. Class DataGenerator Abstract class DataGenerator is the base class of subclasses DataRandom, DataSorted, DataReverseSorted, and DataAllZeros. Each subclass s member function generate_data() generates a vector of data that is random, already sorted, sorted in reverse, and all zeros, respectively. 3

4 The main() in SortTests.cpp The main program tests each sorting algorithm for data sizes 10, 100, 1000, and 10,000. It tests each algorithm against data that is random, already sorted, sorted in reverse, and all zeros. It outputs a table similar to the one below. Classes to complete Complete the implementation (.cpp files) of the following classes for this assignment: Element Node DataGenerator DataRandom DataSorted DataReverseSorted DataAllZeros InsertionSort ShellSortSuboptimal ShellSortOptimal QuickSorter QuickSortSuboptimal QuickSortOptimal LinkedList MergeSort Comparing the algorithms To compare the performances of the sorting algorithms, keep track of these statistics for each algorithm at each data size: The total number of copy constructor calls for the data elements being sorted. The total number of destructor calls of the data elements. The total number of times a data element is moved. Count one move whenever an element moves from one part of the vector or linked list to another. Whenever two elements are swapped, that counts as two moves. The total number of compares of two data elements. Count one compare whenever a data element is compared against another element. The amount of elapsed time (in milliseconds) required to do the sort. Collect these statistics only during sorting. Sample output The following pages show sample output. Your statistics may not be exactly as shown, but your move and compare counts should be close. 4

5 =============== Unsorted random =============== N = 10 N = 100 N = 1,000 Selection sort Insertion sort Shellsort suboptimal Shellsort optimal Quicksort suboptimal Quicksort optimal Mergesort Selection sort ,950 0 Insertion sort ,665 2,670 0 Shellsort suboptimal Shellsort optimal Quicksort suboptimal Quicksort optimal ,068 0 Mergesort Selection sort 1,992 1,992 1, ,500 5 Insertion sort , ,246 5 Shellsort suboptimal 8,006 8,006 10,721 14,356 0 Shellsort optimal 5,457 5,457 12,101 13,807 0 Quicksort suboptimal 3,843 3,843 7,686 12,194 0 Quicksort optimal 4,442 4,442 8,884 13,968 0 Mergesort ,703 0 N = 10,000 Selection sort 19,989 19,989 19,980 49,995, Insertion sort 9,999 9,999 25,086,032 25,086, Shellsort suboptimal 120, , , ,278 7 Shellsort optimal 75,243 75, , ,576 6 Quicksort suboptimal 45,561 45,561 91, ,362 4 Quicksort optimal 51,906 51, , ,077 4 Mergesort ,

6 ============== Already sorted ============== N = 10 N = 100 N = 1,000 Selection sort Insertion sort Shellsort suboptimal Shellsort optimal Quicksort suboptimal Quicksort optimal Mergesort Selection sort ,950 0 Insertion sort Shellsort suboptimal Shellsort optimal Quicksort suboptimal ,150 0 Quicksort optimal Mergesort Selection sort ,500 4 Insertion sort Shellsort suboptimal 8,006 8, ,006 0 Shellsort optimal 5,457 5, ,457 0 Quicksort suboptimal 2,000 2,000 4, ,500 3 Quicksort optimal 2,000 2,000 4,000 12,987 0 Mergesort ,932 0 N = 10,000 Selection sort 9,999 9, ,995, Insertion sort 9,999 9, ,999 0 Shellsort suboptimal 120, , ,005 2 Shellsort optimal 75,243 75, ,243 1 Quicksort suboptimal 20,000 20,000 40,000 50,015, Quicksort optimal 20,000 20,000 40, ,631 2 Mergesort ,

7 ============== Reverse sorted ============== N = 10 N = 100 N = 1,000 Selection sort Insertion sort Shellsort suboptimal Shellsort optimal Quicksort suboptimal Quicksort optimal Mergesort Selection sort ,950 0 Insertion sort ,049 4,950 0 Shellsort suboptimal Shellsort optimal Quicksort suboptimal ,150 0 Quicksort optimal Mergesort Selection sort 1,499 1,499 1, ,500 6 Insertion sort , ,500 8 Shellsort suboptimal 8,006 8,006 9,072 11,716 0 Shellsort optimal 5,457 5,457 6,855 8,550 0 Quicksort suboptimal 2,000 2,000 4, ,500 3 Quicksort optimal 2,502 2,502 5,004 12,987 0 Mergesort ,044 0 N = 10,000 Selection sort 14,999 14,999 10,000 49,995, Insertion sort 9,999 9,999 50,004,999 49,995, Shellsort suboptimal 120, , , ,578 3 Shellsort optimal 75,243 75,243 93, ,190 2 Quicksort suboptimal 20,000 20,000 40,000 50,015, Quicksort optimal 25,002 25,002 50, ,631 2 Mergesort ,

8 ========== All zeroes ========== N = 10 N = 100 N = 1,000 Selection sort Insertion sort Shellsort suboptimal Shellsort optimal Quicksort suboptimal Quicksort optimal Mergesort Selection sort ,950 0 Insertion sort Shellsort suboptimal Shellsort optimal Quicksort suboptimal Quicksort optimal Mergesort Selection sort ,500 3 Insertion sort Shellsort suboptimal 8,006 8, ,006 0 Shellsort optimal 5,457 5, ,457 0 Quicksort suboptimal 5,938 5,938 11,876 9,876 0 Quicksort optimal 5,938 5,938 11,876 12,876 0 Mergesort ,932 0 N = 10,000 Selection sort 9,999 9, ,995, Insertion sort 9,999 9, ,999 0 Shellsort suboptimal 120, , ,005 3 Shellsort optimal 75,243 75, ,243 1 Quicksort suboptimal 74,613 74, , ,226 3 Quicksort optimal 74,613 74, , ,226 3 Mergesort ,608 2 Done! 3 seconds. 8

9 Using code from books and the Web Many books and Web articles will contain code for these sorting algorithms. If you use code from these sources, you must cite your sources (book or URL) in your program comments. Otherwise you can be caught by the software plagiarism checker. Of course, you should understand what the code is doing, and not simply copy it. Copying from another student s program is still strictly forbidden. What to submit If you time out in CodeCheck, then run with only 10, 100, and 1000 data elements. Include 10,000 data elements outside of CodeCheck and copy that output into a text file. Submit the signed zip file from CodeCheck into Canvas: Assignment 12. Sorting algorithms. Also submit the text file containing the output from larger numbers of data elements. Due to use of random numbers in this assignment, CodeCheck will not compare your output. Rubrics Criteria Output (counts should be close to the sample output) Insertion sort Shellsort suboptimal Shellsort optimal Quicksort suboptimal Quicksort optimal Mergesort Algorithm classes Element Node DataGenerator DataRandom DataSorted DataReverseSorted DataAllZeros InsertionSort ShellSortSuboptimal ShellSortOptimal QuickSorter QuickSortSuboptimal QuickSortOptimal LinkedList MergeSort Maximum points

10 Academic integrity You may study together and discuss the assignments, but what you turn in must be your individual work. Assignment submissions will be checked for plagiarism using Moss ( Copying another student s program or sharing your program is a violation of academic integrity. Moss is not fooled by renaming variables, reformatting source code, or re-ordering functions. Violators of academic integrity will suffer severe sanctions, including academic probation. Students who are on academic probation are not eligible for work as instructional assistants in the university or for internships at local companies. 10