University of Waterloo CS240 Winter 2018 Assignment 2. Due Date: Wednesday, Jan. 31st (Part 1) resp. Feb. 7th (Part 2), at 5pm

Transcription

1 University of Waterloo CS240 Winter 2018 Assignment 2 version: :38 Due Date: Wednesday, Jan. 31st (Part 1) resp. Feb. 7th (Part 2), at 5pm Please read the guidelines on submissions: w18/guidelines.pdf. This assignment contains written questions and a programming question. Submit your written solutions electronically as a PDF with files named a02p1wp.pdf (for Part 1) and a02p2wp.pdf (for Part 2) using MarkUs. We will also accept individual question files named a02q1w.pdf, a02q2w.pdf, a02q4w.pdf, a02q5w.pdf and a02q6w.pdf if you wish to submit questions as you complete them. For Problem 3, submit your files pyramid.h and pyramid.cpp based on the skeleton files. Note: you may assume all logarithms are base 2 logarithms: log = log 2. Part 1 due Jan 31st Problem 1 [10 + (5) marks] Design an algorithm for the following problem: Given array A[0..n 1] of n (pairwise distinct) elements and a number k {0,..., n 1}, rearrange the elements so that the first k positions contain the k smallest elements in sorted order. Formally, after the execution we require A[0] A[1] A[k 2] A[k 1] and i {k,..., n 1} : A[k 1] A[i]. to hold. The elements can be any objects; only assume a total order of the elements (given via a suitably overloaded operator <). For full credit, your algorithm has to have running time in O(n + k log n) and use O(1) extra space. Correct algorithms violating one or both requirements give partial credit. Bonus: Give an algorithm with running time in O(n + k log k). 1

2 Problem 2 [6+7+7+(10) = 20 + (10) marks] A pyramid is a data structure that can form the basis of another implementation of the priority queue ADT. Here is an example with 9 nodes: 79 P00 level 0 68 P10 46 P11 level 1 67 P20 35 P21 30 P22 level 2 15 P30 34 P31 22 P32 level 3 A pyramid has to satisfy the following two properties: Structural property: A pyramid P consists of l 0 levels. The ith level, for 0 i < l, contains at most i + 1 entries, denoted by P i, 0,..., P i,i. All levels except (possibly) the last are completely filled; the last level is left-justified. Ordering property: Any node P i,j has at most two children: P i+1,j and P i+1,j+1, provided those nodes exist. The priority of a node is always greater or equal to the priority of both its children. You may assume that all elements stored in the pyramid are pairwise distinct. a) Show that a pyramid with n nodes has height Θ( n). b) Assume you can access the key, leftchild, rightchild, leftparent, and rightparent of a given node in O(1) time. Give an implementation in pseudocode for the deletemax operation in pyramids. The running time of your algorithm must be linear in the height of the pyramid. Hint: Try to mimic deletemax for heaps. c) Give an implementation in pseudocode for the insert operation in pyramids. The running time of your algorithm must be linear in the height of the pyramid. d) Bonus (hard): The boolean operation contains(x) takes a priority value x and returns whether or not a priority queue contains an item with priority x. In binary heaps, we have to search the entire heap in the worst case. For pyramids, in contrast, we can implement contains much faster. Describe an implementation for contains in pyramids with running time in O( n log n). For your implementation, you may use a function get(i, j) = P i,j that returns the node with given coordinates in O(1) time. 2

3 Problem 3 [ = 30 marks] In this problem we implement the pyramid data structure from Problem 2 where the items to store are simply integers. The priority of a number x is simply x itself. Like for heaps, a pyramid P with n elements can be stored in an array using the top-down left-right level-wise order of the nodes: P 0,0, P 1,0, P 1,1, P 2,0, P 2,1, P 2,2, P 3,0, P 3,1,... The implementation keeps a variable size to store the current number of elements in the pyramid (initially 0), so that A[0..size-1] stores the elements of the pyramid. You may assume that all elements stored in the pyramid are pairwise distinct. a) Implement the class constructor initializing the fixed-size array int A[] (whose size N is provided in the constructor). b) Add procedures leftchild, rightchild, leftparent and rightparent, all of which take an index (between 0 and size 1) and return the index of the appropriate element in the pyramid. If the respective node does not exist, you must return 1. c) Implement void insert(int x) and int deletemax() for array-based pyramids. Hint: Your implementation should build upon your pseudocode from Problem 2. Skeleton files are provided on the course website; they are also embedded in this pdf (not working with all viewers): The main method in pyramid.cpp contains a rudimentary CLI interface using cin and cout for testing the pyramids. 3

4 Part 2 due Feb 7th Problem 4 [9+1 = 10 marks] a) Fill out the following table for the sorting methods we discussed in class. Algorithm inputs worst case time in-place? stable? e. g. comparison based, order of growth of numbers in {0,..., R m order of growth 1} space usage in O(1)? PQ-Sort (heaps) comparison-based Θ(n log n) no no Mergesort a Heapsort b Quicksort c Bucketsort d Countsort e LSD-Radix-Sort f MSD-Radix-Sort g a Module 1 slide 37 b Module 2 slide 22 c Module 3 slide 16, but using random pivots from choose-pivot2 d Module 3 slide 24 e Module 3 slide 27 f Module 3 slide 29 g Module 3 slide 30 An algorithm is stable, if the relative order of elements that compare equal is the same in the input and in the sorted output; see also Module 3, slide 24. For all no-entries in this column, give a counterexample showing that the algorithm is not stable. You are not expected to prove the other entries. If you think in some case that the answer may depend on exactly how the algorithm is implemented, you may give it depends as your answer, and briefly discuss what it depends on (outside of the table). b) The holy grail of sorting methods is a method that (i) works for any type of objects that are totally ordered, (ii) has runtime in O(n log n) in the worst case, (iii) sorts in place, (iv) and is stable. Have we seen a holy-grail sort in class? 4

5 Problem 5 [ (5) + 5 = 20 + (5) marks] In this exercise, we consider sorting in a specific streaming model: You are given n (pairwise distinct) elements as an input stream I, from which you can obtain the elements one at a time, and you are supposed to put your output into an output stream O, again one at a time. You cannot otherwise gain access or modify I and O. You can imagine the streams as two queues, where I allows only the dequeue operation and O allows only enqueue. The total number n elements in the input is known to you up front. Apart from the source and sink queues I and O (and potentially a constant amount of local variables), your only means of storing elements is one stack S. Note that this means that at any point in time, you can only do the following operations: Take an element from I or from the top of S; put the element into O or onto S. O I S Remark: Comparisons are only possible between the element currently at the top of S and the element currently at the front of I. Hence between any two (non-redundant) comparisons we must have a move I S or S O. a) Prove that in the above model, it is not always possible to produce a sorted output stream, i. e., for some permutations of the n elements in I, we cannot insert the elements into O in ascending order. You may assume a large enough n for the purpose of this proof. b) Now assume O is used as input for a second round, i.e., O and I are connected and form one large queue. We assume for simplicity that we always finish one round of moving the n items through the stack before starting the next round, i. e., before we are allowed to take an element the second time out of I, we must have put all other elements into O first. That means, elements cannot lap each other and any execution has a well-defined number of rounds k. 5

6 Design a sorting algorithm for this model, i. e., a program that outputs a sequence of moves I S or S O. These operations are the only means of rearranging the data, but your algorithm may take any amount of time and space for computing the next move and can compare the elements S.top() and I.front() for free. Analyze how many rounds your algorithm needs in the worst case for sorting an input of n (distinct) elements. For full credit, your algorithm must achieve k O(log n). Hint: You may take inspiration from sorting with tape drives: Bonus (hard): Find an algorithm with k log 2 n. c) Prove a nontrivial lower bound on k valid for any sorting method in the model. Problem 6 [ (10) = 20 + (10) marks] A former student let s call him Goofy finally made it: He is starting his new job as a software developer! Goofy somehow made it through CS 240, but he never fully understood all the fuzz about binary search, mergesort, insertionsort and the like, but he does remember a professor mentioning that actually insertionsort uses an almost optimal number of comparisons when combined with binary search to find the insertion position. In Goofy s first project, the need for an in-place sorting method arises, i. e., a method that uses only constant extra space to sort a given array. Since insertionsort is such a method, Goofy jumps ahead and implements it; but of course not without adding the tweak of using binary search with it. Goofy-Sort: 1. While the array A[0..n 1] is not sorted, repeat: 1.1. Draw i uniformly at random from {0,..., n 1} Let x := A[i] Remove x from A, i. e., for k := i, i + 1,..., n 2 do A[k] := A[k + 1] Let j be the index returned by binary search on A[0..n 2] with key x For k := n 1, n 2,..., j + 1 do A[k] := A[k 1] A[j] := x. As a reminder, binary search is the following procedure (Goofy googled for it, so it must be correct): 1 binarysearch(a[0..n-1], k) 2 lo = 0; hi = n-1 3 while lo <= hi 4 m = lo + (hi-lo)/2 // approx. middle 5 if (k < A[m]) hi = m-1 6

7 6 else if (k > A[m]) lo = m+1 7 else /*k == A[m]*/ return m 8 return lo a) Explain in a few sentences what Goofy s algorithm does and why it should be seen as problematic. b) Give a proper version (in pseudocode) for Insertionsort with binary search to find the insertion position. Determine the number of comparisons (order of growth) of your algorithm. Is this a good sorting method? c) Goofy being a professional programmer of course did unit test his code to check its correctness. And indeed he found it works fine! Prove that the expected number of rounds (i. e., executions of the while loop in step 1) is at most n 2 /2 = O(n 2 ) for any input with n elements. (This implies in particular that Goofy-sort terminates almost surely.) Hint: What happens if the chosen element x happens to be the smallest or largest in the array? Where does it end up and can it ever be moved again? How long do you have to wait in expectation until a given element (out of n) is chosen? d) Bonus: Run the method on at least 10 inputs times each and compute the average number of rounds needed to sort it by Goofy sort. How do the sample averages compare with the upper bound from above? 7