Worksheet/Lab on Comparing Sorting Algorithms and on the Use of Algebra to Improve Efficiency

This assignment has two parts:

• a programming-based exercise to time and compare five sorting algorithms
• a worksheet-based exercise on algebra-based algorithms

Comparison of Sorting Algorithms

This part of this worksheet/lab asks you compare the performance of five sorting algorithms, including:

• Straight Selection Sort (analyzed on slides for Day 1)
• Insertion sort (discussed on September 8 approximately)
• Hybrid Quicksort (swap pivot with random element, use insertion sort for small array segments)
• Merge sort (Discussed on September 15 approximately and on the Worksheet/Lab on Quicksort, Partition, and Topological Sorting)
• Heap sort (Discussed on October 6, 11, approximately)

To experimentally determine the efficiency of these algorithms, this exercises asks you to use program sort-comparisons.c. (Thus, coding must be in C/C++.) This program provides a framework in which each algorithm can be timed on several data sets in ascending, random, and descending order. Several details for this exercise follow:

• sort-comparisons.c provides code for the Straight Selection Sort and Insertion Sort, taken from class discussions and slides.

• You will need to add code for the Hybrid Quicksort, Merge Sort, and Heap Sort, based on the readings from the textbook and in-class discussion.

  • The code for the Hybrid Quicksort should utilize the best sorting option from the Worksheet/Lab on Quicksort, Partition, and Topological Sorting. Thus, your code likely should include a partition function in which an inner loop scans down to find a small item, then scans up to find a large item, and then swaps the small and large items. Similarly, the sorting algorithm should switch from a quicksort to an insertion sort for small array segments (perhaps segments of 9 or less). If your previous lab indicated some other version of quicksort was faster, contact the instructor for further guidance.

  • The code for the Merge Sort must follow the outline given in the Reading on Merge Sort. Note that many implementations of a merge sort devote considerable time and effort to allocating (and deallocating) temporary arrays. However, the entire algorithm can be accomplished with only one auxiliary array of the same size as the original (and no other arrays). Further, for most steps of the algorithm, there is no need to copy data twice—first to a new array and then back to the original. For this sort, any correct code for a proper merge sort will obtain at least half credit for the merge sort, but code with much memory allocation/deallocation or excessive copying of data between arrays may lose up to 50% of the merge-sort points.

  • The Heap Sort draws upon the heap data structure, introduced in the Workshop/Lab on ... Heaps. The key procedure has the following specification:

    /** *******************************************************************************
     * percDown function                                                              *
     * @param  array  the array to be made into a heap, starting at hold              *
     * @param  hole:  base of subtree for start of processing                         *
     * @param  size  the size of the array                                            *
     * @pre   all nodes in left and right subtrees of the hole node are heaps         *
     * @post  all nodes in the tree from the hole node downward form a hea            *
     *********************************************************************************/
    void percDown(int array [ ], int hole, int size)
            

    With this procedure, a Heap Sort uses the following code:

    ** *******************************************************************************
     * heap sort, main function                                                       *
     * @param  a  the array to be sorted                                              *
     * @param  n  the size of the array                                               *
     * @post  the first n elements of a are sorted in non-descending order            *
     *********************************************************************************/
    
    void heapSort (int a [ ], int n) {
        // Build Heap
        for (int i=n/2 ; i>=0 ; i-- ) {
            percDown(a, i, n);
        }
    
        for (int i=n-1 ; i>0 ; i-- ) {
          int tmp = a[0];
          a[0] = a[i];
          a[i] = tmp   ; // deleteMax
          percDown( a, 0, i); // Maintain heap ordering property
        }
    
    }
            

    Additional details may be found in Levitin's text, Section 6.4.

• Since an important point of this exercise is to compare sorting algorithms, you should try to code each algorithm efficiently in a similar style.

With those notes, details of this part of the lab-based exercise follow:

1. Complete the Hybrid Quicksort, Merge Sort, and Heap Sort in sort-comparisons.c as described above. You may NOT change the main procedure in any way, unless you have explicit permission from the instructor. Of course, your code must follow the CS 415 C/C++ Style Guide for Fall 2022.

2. Review the sort-comparisons.c program to answer the following:

   1. What is the purpose of the struct sorts structure? How is this type used in the program
   2. What is the purpose of the arrays, algAscActive, algRanActive and algDesActive?
   3. When the program is run, sometimes the timing for an algorithm on a data set is given by a number (in seconds) and sometimes as ---. How does the program decide when each of these results will be printed?
   4. The code copies data sets from asc, ran, dex to tempAsc, tempRan, tempDes for each algorithm. Why is this copying necessary?
   5. What is the purpose of the functions checkAscValues and checkAscending? Explain how these functions help automate checking that the algorithms are properly coded. Also, explain why both procedures are needed—why not just use one of these procedures for checking?

3. Once the program runs properly, print a copy of the results (you can copy and paste from a terminal window to an editor that uses a fixed-width font). Then analyze the results to answer these questions:

   1. For θ(n²) sorts, one would expect processing time to increase by a factor of 4 when the size of the data set doubles. Explain why. Although experimental data may show some variation, review the timings obtained and identify which sorts show this increase in processing times.
   2. For θ(n) sorts, one would expect processing times to double when the size of the data set doubles. Explain why, and discuss which, if any, sorts show this increase in processing times.
   3. For θ(n log n) sorts, one would expect processing times to increase a little more than double when the data set doubles in size. Explain why, and discuss which, if any, sorts show this increase in processing times.

Using Algebra to Improve Efficiency

Horner's Rule

4. A polynomial function has the form

   p(x) = a_nxⁿ + a_n-1x^n-1 + ... + a₂x² + a₁x + a₀

   Write a function compute_poly that takes three parameters:

   • an x value,
   • an integer n which gives the largest power of x with a non-zero coefficient, and
   • an array a of n+1 coefficients (a₀, a₁, ..., a_n-1, a_n).

   and returns the value of the polynomial p(x).

   Notes:

   • compute_poly should make only one pass through the list of coefficients.
   • Both the number x and the elements of the array a should be real numbers (e.g., of type double) rather than integers.
   • The number x may be used in a multiplication operation no more than n times in the entire computation. (Thus, recomputing xⁱ from scratch for each of the n terms is not acceptable for this problem.)
   • Since the pow function in the math.h library requires many multiplication operations, use of pow in this problem would violate the condition that no more than n multiplications are allowed in the entire solution to this problem. (To be specific, use of pow in this program will yield an automatic score of 0 for this program.)
   • As a hint, you may want to search for discussion of Horner's Rule either in a book on numerical analysis or on the Web.
   • Be sure that the array element a[n] is used as the coefficient of xⁿ (not the coefficient of x⁰).
   • You will need to include compute_poly in a main program for testing.
   • Be sure your testing covers an appropriate range of cases.
   • compute_poly should return the result of the computation, not print the result. (Any printf statement in compute_poly is subject to a 12 point penalty!)

5. Refer to Levitin, Section 6.5, to complete the following when a = 3.

   1. Apply the left-to-right binary exponentiation algorithm to compute a¹³.
   2. Apply the right-to-left binary exponentiation algorithm to compute a¹³.

   Notes: For each part of this problem:

   • show each step in the computation,
   • it is permissible to use a calculator to do no more than 6 multiplications (but no other arithmetic operations).