1 / 34

CS 332: Algorithms

This text provides a comprehensive review of the Quicksort algorithm, including its implementation and a real-world example of its application in simulating combat billiards. Topics covered include heaps, priority queues, and sorting algorithms.

emilye
Download Presentation

CS 332: Algorithms

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS 332: Algorithms Quicksort David Luebke 110/22/2019

  2. Administrivia • Head count: how many people can’t make it to the scheduled office hours? • How many people would be interested in organizing tutors for this class? • Reminder: homework due tonight at midnight (drop box) David Luebke 210/22/2019

  3. A = 16 14 10 8 7 9 3 2 4 1 Review: Heaps • A heap is a “complete” binary tree, usually represented as an array: 16 4 10 14 7 9 3 2 8 1 David Luebke 310/22/2019

  4. Review: Heaps • To represent a heap as an array: Parent(i) { return i/2; } Left(i) { return 2*i; } right(i) { return 2*i + 1; } David Luebke 410/22/2019

  5. Review: The Heap Property • Heaps also satisfy the heap property: A[Parent(i)]  A[i] for all nodes i > 1 • In other words, the value of a node is at most the value of its parent • The largest value is thus stored at the root (A[1]) • Because the heap is a binary tree, the height of any node is at most (lg n) David Luebke 510/22/2019

  6. Review: Heapify() • Heapify(): maintain the heap property • Given: a node i in the heap with children l and r • Given: two subtrees rooted at l and r, assumed to be heaps • Action: let the value of the parent node “float down” so subtree at i satisfies the heap property • If A[i] < A[l] or A[i] < A[r], swap A[i] with the largest of A[l] and A[r] • Recurse on that subtree • Running time: O(h), h = height of heap = O(lg n) David Luebke 610/22/2019

  7. Review: BuildHeap() • BuildHeap(): build heap bottom-up by running Heapify() on successive subarrays • Walk backwards through the array from n/2 to 1, calling Heapify() on each node. • Order of processing guarantees that the children of node i are heaps when i is processed • Easy to show that running time is O(n lg n) • Can be shown to be O(n) • Key observation: most subheaps are small David Luebke 710/22/2019

  8. Review: Heapsort() • Heapsort(): an in-place sorting algorithm: • Maximum element is at A[1] • Discard by swapping with element at A[n] • Decrement heap_size[A] • A[n] now contains correct value • Restore heap property at A[1] by calling Heapify() • Repeat, always swapping A[1] for A[heap_size(A)] • Running time: O(n lg n) • BuildHeap: O(n), Heapify: n * O(lg n) David Luebke 810/22/2019

  9. Tying It Into The Real World • And now, a real-world example… David Luebke 910/22/2019

  10. Tying It Into The “Real World” • And now, a real-world example…combat billiards • Sort of like pool... • Except you’re trying to kill the other players… • And the table is the size of a polo field… • And the balls are the size of Suburbans... • And instead of a cueyou drive a vehicle with a ram on it • Problem: how do you simulate the physics? Figure 1: boring traditional pool David Luebke 1010/22/2019

  11. Combat Billiards:Simulating The Physics • Simplifying assumptions: • G-rated version: No players • Just n balls bouncing around • No spin, no friction • Easy to calculate the positions of the balls at time Tnfrom time Tn-1 if there are no collisions in between • Simple elastic collisions David Luebke 1110/22/2019

  12. Simulating The Physics • Assume we know how to compute when two moving spheres will intersect • Given the state of the system, we can calculate when the next collision will occur for each ball • At each collision Ci: • Advance the system to the time Ti of the collision • Recompute the next collision for the ball(s) involved • Find the next overall collision Ci+1 and repeat • How should we keep track of all these collisions and when they occur? David Luebke 1210/22/2019

  13. Review: Priority Queues • The heap data structure is often used for implementing priority queues • A data structure for maintaining a set S of elements, each with an associated value or key • Supports the operations Insert(), Maximum(), and ExtractMax() • Commonly used for scheduling, event simulation David Luebke 1310/22/2019

  14. Priority Queue Operations • Insert(S, x) inserts the element x into set S • Maximum(S) returns the element of S with the maximum key • ExtractMax(S) removes and returns the element of S with the maximum key David Luebke 1410/22/2019

  15. Implementing Priority Queues HeapInsert(A, key) // what’s running time? { heap_size[A] ++; i = heap_size[A]; while (i > 1 AND A[Parent(i)] < key) { A[i] = A[Parent(i)]; i = Parent(i); } A[i] = key; } David Luebke 1510/22/2019

  16. Implementing Priority Queues HeapMaximum(A) { // This one is really tricky: return A[i]; } David Luebke 1610/22/2019

  17. Implementing Priority Queues HeapExtractMax(A) { if (heap_size[A] < 1) { error; } max = A[1]; A[1] = A[heap_size[A]] heap_size[A] --; Heapify(A, 1); return max; } David Luebke 1710/22/2019

  18. Back To Combat Billiards • Extract the next collision Ci from the queue • Advance the system to the time Ti of the collision • Recompute the next collision(s) for the ball(s) involved • Insert collision(s) into the queue, using the time of occurrence as the key • Find the next overall collision Ci+1 and repeat David Luebke 1810/22/2019

  19. Using A Priority Queue For Event Simulation • More natural to use Minimum() and ExtractMin() • What if a player hits a ball? • Need to code up a Delete() operation • How?What will the running time be? David Luebke 1910/22/2019

  20. Quicksort • Sorts in place • Sorts O(n lg n) in the average case • Sorts O(n2) in the worst case • So why would people use it instead of merge sort? David Luebke 2010/22/2019

  21. Quicksort • Another divide-and-conquer algorithm • The array A[p..r] is partitioned into two non-empty subarrays A[p..q] and A[q+1..r] • Invariant: All elements in A[p..q] are less than all elements in A[q+1..r] • The subarrays are recursively sorted by calls to quicksort • Unlike merge sort, no combining step: two subarrays form an already-sorted array David Luebke 2110/22/2019

  22. Quicksort Code Quicksort(A, p, r) { if (p < r) { q = Partition(A, p, r); Quicksort(A, p, q); Quicksort(A, q+1, r); } } David Luebke 2210/22/2019

  23. Partition • Clearly, all the action takes place in the partition() function • Rearranges the subarray in place • End result: • Two subarrays • All values in first subarray  all values in second • Returns the index of the “pivot” element separating the two subarrays • How do you suppose we implement this function? David Luebke 2310/22/2019

  24. Partition In Words • Partition(A, p, r): • Select an element to act as the “pivot” (which?) • Grow two regions, A[p..i] and A[j..r] • All elements in A[p..i] <= pivot • All elements in A[j..r] >= pivot • Increment i until A[i] >= pivot • Decrement j until A[j] <= pivot • Swap A[i] and A[j] • Repeat until i >= j • Return j David Luebke 2410/22/2019

  25. Partition Code Partition(A, p, r) x = A[p]; i = p - 1; j = r + 1; while (TRUE) repeat j--; until A[j] <= x; repeat i++; until A[i] >= x; if (i < j) Swap(A, i, j); else return j; Illustrate on A = {5, 3, 2, 6, 4, 1, 3, 7}; What is the running time of partition()? David Luebke 2510/22/2019

  26. Analyzing Quicksort • What will be the worst case for the algorithm? • What will be the best case for the algorithm? • Which is more likely? • Will any particular input elicit the worst case? David Luebke 2610/22/2019

  27. Analyzing Quicksort • What will be the worst case for the algorithm? • Partition is always unbalanced • One subarray is size n - 1, the other is size 1 • This happens when q = p • What will be the best case for the algorithm? • Which is more likely? • Will any particular input elicit the worst case? David Luebke 2710/22/2019

  28. Analyzing Quicksort • What will be the worst case for the algorithm? • Partition is always unbalanced • What will be the best case for the algorithm? • Partition is perfectly balanced • Both subarrays of size n/2 • Which is more likely? • Will any particular input elicit the worst case? David Luebke 2810/22/2019

  29. Analyzing Quicksort • What will be the worst case for the algorithm? • Partition is always unbalanced • What will be the best case for the algorithm? • Partition is perfectly balanced • Which is more likely? • The latter, by far • Except... • Will any particular input elicit the worst case? David Luebke 2910/22/2019

  30. Analyzing Quicksort • What will be the worst case for the algorithm? • Partition is always unbalanced • What will be the best case for the algorithm? • Partition is perfectly balanced • Which is more likely? • The latter, by far, except... • Will any particular input elicit the worst case? • Yes: Already-sorted input David Luebke 3010/22/2019

  31. Analyzing Quicksort • In the worst case: T(1) = (1) T(n) = T(n - 1) + (n) • What does this work out to? T(n) = (n2) David Luebke 3110/22/2019

  32. Analyzing Quicksort • In the best case: T(n) = 2T(n/2) + (n) • What does this work out to? T(n) = (n lg n) (by the Master Theorem) David Luebke 3210/22/2019

  33. Improving Quicksort • The real liability of quicksort is that it runs in O(n2) on already-sorted input • What can we do about this? • Book discusses two solutions: • Randomize the input array • Pick a random pivot element • How will these solve the problem? David Luebke 3310/22/2019

  34. Coming Up • Up next: Analyzing randomized quicksort David Luebke 3410/22/2019

More Related