![Page 1: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/1.jpg)
Merge Sort
![Page 2: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/2.jpg)
What Is Sorting?
• To arrange a collection of items in some specified order.• Numerical order • Lexicographical order
• Input: sequence <a1, a2, …, an> of numbers.• Output: permutation <a'1, a'2, …, a’n> such that a'1 £ a'2£ … £ a'n .
• Example• Start à 1 23 2 56 9 8 10 100• End à 1 2 8 9 10 23 56 100
2
![Page 3: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/3.jpg)
Why Sort?
¨ A classic problem in computer science.
• Data requested in sorted order• e.g., list students in increasing GPA order
¨ Searching
• To find an element in an array of a million elements
• Linear search: average 500,000 comparisons• Binary search: worst case 20 comparisons
• Database, Phone book¨ Eliminating duplicate copies in a collection of records¨ Finding a missing element, Max, Min
3
![Page 4: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/4.jpg)
Sorting Algorithms
• Selection Sort Bubble Sort• Insertion Sort Shell Sort• T(n)=O(n2) Quadratic growth• In clock time
• Double input -> 4X time• Feasible for small inputs, quickly unmanagable
• Halve input -> 1/4 time• Hmm... can recursion save the day?• If have two sorted halves, how to produce sorted full result?
4
10,000 3 sec 20,000 17 sec
50,000 77 sec 100,000 5 min
![Page 5: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/5.jpg)
Divide and Conquer
1. Base case: the problem is small enough, solve directly
2. Divide the problem into two or more similar and smaller subproblems
3. Recursively solve the subproblems
4. Combine solutions to the subproblems
5
![Page 6: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/6.jpg)
Merge Sort6
• Divide and conquer algorithm• Worst case: O(nlogn)• Stable
• maintain the relative order of records with equal values
• Input: 12, 5, 8, 13, 8, 27 • Stable: 5, 8, 8, 12, 13, 27 • Not Stable:5, 8, 8, 12, 13, 27
![Page 7: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/7.jpg)
Merge Sort: Idea7
Merge
Recursively sort
Divide intotwo halves
FirstPart SecondPart
FirstPart SecondPart
A:
A is sorted!
![Page 8: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/8.jpg)
Merge-Sort: Merge8
Sorted Sorted
merge
A:
L: R:
Sorted
![Page 9: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/9.jpg)
Merge Example9
L: R:1 2 6 8 3 4 5 7
A:
![Page 10: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/10.jpg)
Merge Example cont.10
1 2 3 4 5 6 7 8
L:
A:
3 5 15 28 6 10 14 22
R:1 2 6 8 3 4 5 7
i=4 j=4
k=8
![Page 11: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/11.jpg)
Merge sort algorithm11
MERGE-SORT A[1 . . n]
1. If n = 1, done.2. Recursively sort A[ 1 . . én/2ù ]
and A[ én/2ù+1 . . n ] .3. “Merge” the 2 sorted lists.
Key subroutine: MERGE
![Page 12: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/12.jpg)
Merge sort (Example) 12
![Page 13: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/13.jpg)
Merge sort (Example) 13
![Page 14: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/14.jpg)
Merge sort (Example) 14
![Page 15: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/15.jpg)
Merge sort (Example) 15
![Page 16: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/16.jpg)
Merge sort (Example) 16
![Page 17: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/17.jpg)
Merge sort (Example)17
![Page 18: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/18.jpg)
Merge sort (Example)18
![Page 19: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/19.jpg)
Merge sort (Example)19
![Page 20: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/20.jpg)
Merge sort (Example)20
![Page 21: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/21.jpg)
Merge sort (Example)21
![Page 22: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/22.jpg)
Merge sort (Example)22
![Page 23: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/23.jpg)
Merge sort (Example)23
![Page 24: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/24.jpg)
Merge sort (Example)24
![Page 25: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/25.jpg)
Merge sort (Example)25
![Page 26: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/26.jpg)
Merge sort (Example)26
![Page 27: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/27.jpg)
Merge sort (Example)27
![Page 28: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/28.jpg)
Merge sort (Example)28
![Page 29: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/29.jpg)
Merge sort (Example) 29
![Page 30: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/30.jpg)
Merge sort (Example)30
![Page 31: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/31.jpg)
Merge sort (Example)31
![Page 32: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/32.jpg)
Analysis of merge sort32
MERGE-SORT A[1 . . n]
1. If n = 1, done.2. Recursively sort A[ 1 . . én/2ù ]
and A[ én/2ù+1 . . n ] .3. “Merge” the 2 sorted lists
T(n)
Q(1)
2T(n/2)
Q(n)
![Page 33: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/33.jpg)
Analyzing merge sort
33
T(n) =Q(1) if n = 1;
2T(n/2) + Q(n) if n > 1.
T(n) = Q(n lg n) (n > 1)
![Page 34: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/34.jpg)
Recursion tree34
Solve T(n) = 2T(n/2) + cn, where c > 0 is constant.
cn
cn/4 cn/4 cn/4 cn/4
cn/2 cn/2
Q(1)
h = log n
cn
cn
cn
#leaves = n Q(n)
Total = Q(n log n)
…
![Page 35: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/35.jpg)
Memory Requirement35
Needs additional n locations because it is difficult to merge two sorted sets in place
L: R:1 2 6 8 3 4 5 7
A:
![Page 36: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/36.jpg)
Conclusion36
• Merge Sort: O(n log n)
• grows more slowly than Q(n2)
• asymptotically beats insertion sort in the worst case
• In practice, merge sort beats insertion sort for n > 30 or so
• Space requirement:
• O(n), not in-place
![Page 37: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/37.jpg)
Heapsort
![Page 38: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/38.jpg)
Heapsort
¨ Merge sort time is O(n log n) but still requires, temporarily, n extra storage locations
¨ Heapsort does not require any additional storage¨ As its name implies, heapsort uses a heap to store
the array
![Page 39: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/39.jpg)
First Version of a Heapsort Algorithm
¨ When used as a priority queue, a heap maintains a smallest value at the top
¨ The following algorithm ¤ places an array's data into a heap, ¤ then removes each heap item (O(n log n)) and moves it back into the
array¨ This version of the algorithm requires n extra storage locations
Heapsort Algorithm: First Version
1. Insert each value from the array to be sorted into a priority queue (heap).
2. Set i to 0
3. while the priority queue is not empty
4. Remove an item from the queue and insert it back into the array at position i
5. Increment i
![Page 40: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/40.jpg)
Revising the Heapsort Algorithm
¨ In heaps we've used so far, each parent node value was not greater than the values of its children
¨ We can build a heap so that each parent node value is not less than its children
¨ Then,¤ move the top item to the bottom of the heap¤ reheap, ignoring the item moved to the bottom
![Page 41: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/41.jpg)
Trace of Heapsort
89
76 74
37 32 39 66
20 26 18 28 29 6
![Page 42: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/42.jpg)
Trace of Heapsort (cont.)
89
76 74
37 32 39 66
20 26 18 28 29 6
![Page 43: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/43.jpg)
Trace of Heapsort (cont.)
89
76 74
37 32 39 66
20 26 18 28 29 6
![Page 44: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/44.jpg)
Trace of Heapsort (cont.)
6
76 74
37 32 39 66
20 26 18 28 29 89
![Page 45: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/45.jpg)
Trace of Heapsort (cont.)
76
6 74
37 32 39 66
20 26 18 28 29 89
![Page 46: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/46.jpg)
Trace of Heapsort (cont.)
76
37 74
6 32 39 66
20 26 18 28 29 89
![Page 47: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/47.jpg)
Trace of Heapsort (cont.)
76
37 74
26 32 39 66
20 6 18 28 29 89
![Page 48: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/48.jpg)
Trace of Heapsort (cont.)
76
37 74
26 32 39 66
20 6 18 28 29 89
![Page 49: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/49.jpg)
Trace of Heapsort (cont.)
76
37 74
26 32 39 66
20 6 18 28 29 89
![Page 50: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/50.jpg)
Trace of Heapsort (cont.)
76
37 74
26 32 39 66
20 6 18 28 29 89
![Page 51: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/51.jpg)
Trace of Heapsort (cont.)
29
37 74
26 32 39 66
20 6 18 28 76 89
![Page 52: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/52.jpg)
Trace of Heapsort (cont.)
74
37 29
26 32 39 66
20 6 18 28 76 89
![Page 53: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/53.jpg)
Trace of Heapsort (cont.)
74
37 66
26 32 39 29
20 6 18 28 76 89
![Page 54: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/54.jpg)
Trace of Heapsort (cont.)
74
37 66
26 32 39 29
20 6 18 28 76 89
![Page 55: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/55.jpg)
Trace of Heapsort (cont.)
74
37 66
26 32 39 29
20 6 18 28 76 89
![Page 56: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/56.jpg)
Trace of Heapsort (cont.)
74
37 66
26 32 39 29
20 6 18 28 76 89
![Page 57: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/57.jpg)
Trace of Heapsort (cont.)
28
37 66
26 32 39 29
20 6 18 74 76 89
![Page 58: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/58.jpg)
Trace of Heapsort (cont.)
66
37 28
26 32 39 29
20 6 18 74 76 89
![Page 59: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/59.jpg)
Trace of Heapsort (cont.)
66
37 39
26 32 28 29
20 6 18 74 76 89
![Page 60: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/60.jpg)
Trace of Heapsort (cont.)
66
37 39
26 32 28 29
20 6 18 74 76 89
![Page 61: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/61.jpg)
Trace of Heapsort (cont.)
66
37 39
26 32 28 29
20 6 18 74 76 89
![Page 62: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/62.jpg)
Trace of Heapsort (cont.)
66
37 39
26 32 28 29
20 6 18 74 76 89
![Page 63: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/63.jpg)
Trace of Heapsort (cont.)
18
37 39
26 32 28 29
20 6 66 74 76 89
![Page 64: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/64.jpg)
Trace of Heapsort (cont.)
39
37 18
26 32 28 29
20 6 66 74 76 89
![Page 65: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/65.jpg)
Trace of Heapsort (cont.)
39
37 29
26 32 28 18
20 6 66 74 76 89
![Page 66: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/66.jpg)
Trace of Heapsort (cont.)
39
37 29
26 32 28 18
20 6 66 74 76 89
![Page 67: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/67.jpg)
Trace of Heapsort (cont.)
39
37 29
26 32 28 18
20 6 66 74 76 89
![Page 68: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/68.jpg)
Trace of Heapsort (cont.)
39
37 29
26 32 28 18
20 6 66 74 76 89
![Page 69: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/69.jpg)
Trace of Heapsort (cont.)
6
37 29
26 32 28 18
20 39 66 74 76 89
![Page 70: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/70.jpg)
Trace of Heapsort (cont.)
37
6 29
26 32 28 18
20 39 66 74 76 89
![Page 71: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/71.jpg)
Trace of Heapsort (cont.)
37
32 29
26 6 28 18
20 39 66 74 76 89
![Page 72: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/72.jpg)
Trace of Heapsort (cont.)
37
32 29
26 6 28 18
20 39 66 74 76 89
![Page 73: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/73.jpg)
Trace of Heapsort (cont.)
37
32 29
26 6 28 18
20 39 66 74 76 89
![Page 74: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/74.jpg)
Trace of Heapsort (cont.)
37
32 29
26 6 28 18
20 39 66 74 76 89
![Page 75: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/75.jpg)
Trace of Heapsort (cont.)
20
32 29
26 6 28 18
37 39 66 74 76 89
![Page 76: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/76.jpg)
Trace of Heapsort (cont.)
32
20 29
26 6 28 18
37 39 66 74 76 89
![Page 77: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/77.jpg)
Trace of Heapsort (cont.)
32
26 29
20 6 28 18
37 39 66 74 76 89
![Page 78: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/78.jpg)
Trace of Heapsort (cont.)
32
26 29
20 6 28 18
37 39 66 74 76 89
![Page 79: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/79.jpg)
Trace of Heapsort (cont.)
32
26 29
20 6 28 18
37 39 66 74 76 89
![Page 80: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/80.jpg)
Trace of Heapsort (cont.)
32
26 29
20 6 28 18
37 39 66 74 76 89
![Page 81: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/81.jpg)
Trace of Heapsort (cont.)
18
26 29
20 6 28 32
37 39 66 74 76 89
![Page 82: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/82.jpg)
Trace of Heapsort (cont.)
29
26 18
20 6 28 32
37 39 66 74 76 89
![Page 83: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/83.jpg)
Trace of Heapsort (cont.)
29
26 28
20 6 18 32
37 39 66 74 76 89
![Page 84: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/84.jpg)
Trace of Heapsort (cont.)
29
26 28
20 6 18 32
37 39 66 74 76 89
![Page 85: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/85.jpg)
Trace of Heapsort (cont.)
29
26 28
20 6 18 32
37 39 66 74 76 89
![Page 86: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/86.jpg)
Trace of Heapsort (cont.)
29
26 28
20 6 18 32
37 39 66 74 76 89
![Page 87: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/87.jpg)
Trace of Heapsort (cont.)
18
26 28
20 6 29 32
37 39 66 74 76 89
![Page 88: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/88.jpg)
Trace of Heapsort (cont.)
28
26 18
20 6 29 32
37 39 66 74 76 89
![Page 89: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/89.jpg)
Trace of Heapsort (cont.)
28
26 18
20 6 29 32
37 39 66 74 76 89
![Page 90: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/90.jpg)
Trace of Heapsort (cont.)
28
26 18
20 6 29 32
37 39 66 74 76 89
![Page 91: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/91.jpg)
Trace of Heapsort (cont.)
28
26 18
20 6 29 32
37 39 66 74 76 89
![Page 92: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/92.jpg)
Trace of Heapsort (cont.)
6
26 18
20 28 29 32
37 39 66 74 76 89
![Page 93: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/93.jpg)
Trace of Heapsort (cont.)
26
6 18
20 28 29 32
37 39 66 74 76 89
![Page 94: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/94.jpg)
Trace of Heapsort (cont.)
26
20 18
6 28 29 32
37 39 66 74 76 89
![Page 95: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/95.jpg)
Trace of Heapsort (cont.)
26
20 18
6 28 29 32
37 39 66 74 76 89
![Page 96: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/96.jpg)
Trace of Heapsort (cont.)
26
20 18
6 28 29 32
37 39 66 74 76 89
![Page 97: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/97.jpg)
Trace of Heapsort (cont.)
26
20 18
6 28 29 32
37 39 66 74 76 89
![Page 98: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/98.jpg)
Trace of Heapsort (cont.)
6
20 18
26 28 29 32
37 39 66 74 76 89
![Page 99: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/99.jpg)
Trace of Heapsort (cont.)
20
6 18
26 28 29 32
37 39 66 74 76 89
![Page 100: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/100.jpg)
Trace of Heapsort (cont.)
20
6 18
26 28 29 32
37 39 66 74 76 89
![Page 101: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/101.jpg)
Trace of Heapsort (cont.)
20
6 18
26 28 29 32
37 39 66 74 76 89
![Page 102: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/102.jpg)
Trace of Heapsort (cont.)
20
6 18
26 28 29 32
37 39 66 74 76 89
![Page 103: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/103.jpg)
Trace of Heapsort (cont.)
18
6 20
26 28 29 32
37 39 66 74 76 89
![Page 104: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/104.jpg)
Trace of Heapsort (cont.)
18
6 20
26 28 29 32
37 39 66 74 76 89
![Page 105: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/105.jpg)
Trace of Heapsort (cont.)
18
6 20
26 28 29 32
37 39 66 74 76 89
![Page 106: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/106.jpg)
Trace of Heapsort (cont.)
18
6 20
26 28 29 32
37 39 66 74 76 89
![Page 107: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/107.jpg)
Trace of Heapsort (cont.)
6
18 20
26 28 29 32
37 39 66 74 76 89
![Page 108: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/108.jpg)
Trace of Heapsort (cont.)
6
18 20
26 28 29 32
37 39 66 74 76 89
![Page 109: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/109.jpg)
Revising the Heapsort Algorithm
¨ If we implement the heap as an array¤ each element
removed will be placed at the end of the array, and
¤ the heap part of the array decreases by one element
![Page 110: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/110.jpg)
Algorithm for In-Place Heapsort
Algorithm for In-Place Heapsort
1. Build a heap by rearranging the elements in an unsorted array
2. while the heap is not empty
3. Remove the first item from the heap by swapping it with the last item in the heap and restoring the heap property
![Page 111: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/111.jpg)
Analysis of Heapsort
¨ Because a heap is a complete binary tree, it has log n levels
¨ Building a heap of size n requires finding the correct location for an item in a heap with log nlevels
¨ Each insert (or remove) is O(log n)¨ With n items, building a heap is O(n log n)¨ No extra storage is needed
![Page 112: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/112.jpg)
Quicksort
![Page 113: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/113.jpg)
Quicksort
¨ Developed in 1962¨ Quicksort selects a specific value called a pivot and
rearranges the array into two parts (called partioning)¤ all the elements in the left subarray are less than or
equal to the pivot¤ all the elements in the right subarray are larger than
the pivot¤ The pivot is placed between the two subarrays
¨ The process is repeated until the array is sorted
![Page 114: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/114.jpg)
Trace of Quicksort
44 75 23 43 55 12 64 77 33
![Page 115: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/115.jpg)
Trace of Quicksort (cont.)
44 75 23 43 55 12 64 77 33
Arbitrarily select the first element as the
pivot
![Page 116: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/116.jpg)
Trace of Quicksort (cont.)
55 75 23 43 44 12 64 77 33
Swap the pivot with the element in the middle
![Page 117: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/117.jpg)
Trace of Quicksort (cont.)
55 75 23 43 44 12 64 77 33
Partition the elements so that all values less than or equal to the pivot are to the left, and all values greater than
the pivot are to the right
![Page 118: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/118.jpg)
Trace of Quicksort (cont.)
12 33 23 43 44 55 64 77 75
Partition the elements so that all values less than or equal to the pivot are to the left, and all values greater than
the pivot are to the right
![Page 119: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/119.jpg)
Quicksort Example(cont.)
12 33 23 43 44 55 64 77 75
44 is now in its correct position
![Page 120: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/120.jpg)
Trace of Quicksort (cont.)
12 33 23 43 44 55 64 77 75
Now apply quicksort recursively to the two
subarrays
![Page 121: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/121.jpg)
Trace of Quicksort (cont.)
12 33 23 43 44 55 64 77 75
Pivot value = 12
![Page 122: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/122.jpg)
Trace of Quicksort (cont.)
12 33 23 43 44 55 64 77 75
Pivot value = 12
![Page 123: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/123.jpg)
Trace of Quicksort (cont.)
12 33 23 43 44 55 64 77 75
Pivot value = 33
![Page 124: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/124.jpg)
Trace of Quicksort (cont.)
12 23 33 43 44 55 64 77 75
Pivot value = 33
![Page 125: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/125.jpg)
Trace of Quicksort (cont.)
12 23 33 43 44 55 64 77 75
Pivot value = 33
![Page 126: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/126.jpg)
Trace of Quicksort (cont.)
12 23 33 43 44 55 64 77 75
Pivot value = 33
Left and right subarrays have single values; they
are sorted
![Page 127: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/127.jpg)
Trace of Quicksort (cont.)
12 23 33 43 44 55 64 77 75
Pivot value = 33
Left and right subarrays have single values; they
are sorted
![Page 128: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/128.jpg)
Trace of Quicksort (cont.)
12 23 33 43 44 55 64 77 75
Pivot value = 55
![Page 129: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/129.jpg)
Trace of Quicksort (cont.)
Pivot value = 64
12 23 33 43 44 55 64 77 75
![Page 130: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/130.jpg)
Trace of Quicksort (cont.)
12 23 33 43 44 55 64 77 75
Pivot value = 77
![Page 131: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/131.jpg)
Trace of Quicksort (cont.)
12 23 33 43 44 55 64 75 77
Pivot value = 77
![Page 132: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/132.jpg)
Trace of Quicksort (cont.)
12 23 33 43 44 55 64 75 77
Pivot value = 77
![Page 133: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/133.jpg)
Trace of Quicksort (cont.)
12 23 33 43 44 55 64 75 77
Left subarray has single value; it is
sorted
![Page 134: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/134.jpg)
Trace of Quicksort (cont.)
12 23 33 43 44 55 64 75 77
![Page 135: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/135.jpg)
Algorithm for Quicksort
¨ We describe how to do the partitioning later¨ The indexes first and last are the end points of the
array being sorted¨ The index of the pivot after partitioning is pivIndex
Algorithm for Quicksort
1. if first < last then
2. Partition the elements in the subarray first . . . last so that the pivot value is in its correct place (subscript pivIndex)
3. Recursively apply quicksort to the subarray first . . . pivIndex - 1
4. Recursively apply quicksort to the subarray pivIndex + 1 . . . last
![Page 136: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/136.jpg)
Analysis of Quicksort
¨ If the pivot value is a random value selected from the current subarray,¤ then statistically half of the items in the subarray will be less
than the pivot and half will be greater
¨ If both subarrays have the same number of elements (best case), there will be log n levels of recursion
¨ At each recursion level, the partitioning process involves moving every element to its correct position—n moves
¨ Quicksort is O(n log n), just like merge sort
![Page 137: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/137.jpg)
Analysis of Quicksort (cont.)
¨ The array split may not be the best case, i.e. 50-50¨ An exact analysis is difficult (and beyond the scope
of this class), but, the running time will be bounded by a constant x n log n
![Page 138: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/138.jpg)
Analysis of Quicksort (cont.)
¨ A quicksort will give very poor behavior if, each time the array is partitioned, a subarray is empty.
¨ In that case, the sort will be O(n2)¨ Under these circumstances, the overhead of
recursive calls and the extra run-time stack storage required by these calls makes this version of quicksort a poor performer relative to the quadratic sorts¤ We’ll discuss a solution later
![Page 139: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/139.jpg)
Algorithm for Partitioning
44 75 23 43 55 12 64 77 33
If the array is randomly ordered, it does not matter which element is the
pivot.
For simplicity we pick the element with subscript first
![Page 140: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/140.jpg)
Trace of Partitioning (cont.)
44 75 23 43 55 12 64 77 33
If the array is randomly ordered, it does not matter which element is the
pivot.
For simplicity we pick the element with subscript first
![Page 141: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/141.jpg)
Trace of Partitioning (cont.)
44 75 23 43 55 12 64 77 33
For visualization purposes, items less than or equal to the pivot will be
colored blue; items greater than the pivot will be colored light purple
![Page 142: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/142.jpg)
Trace of Partitioning (cont.)
44 75 23 43 55 12 64 77 33
For visualization purposes, items less than or equal to the pivot will be
colored blue; items greater than the pivot will be colored light purple
![Page 143: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/143.jpg)
Trace of Partitioning (cont.)
Search for the first value at the left end of the array that is greater
than the pivot value
44 75 23 43 55 12 64 77 33
![Page 144: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/144.jpg)
Trace of Partitioning (cont.)
Search for the first value at the left end of the array that is greater
than the pivot value
up
44 75 23 43 55 12 64 77 33
![Page 145: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/145.jpg)
Trace of Partitioning (cont.)
Then search for the first value at the right end of the array that is less than or equal to the pivot value
up
44 75 23 43 55 12 64 77 33
![Page 146: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/146.jpg)
Trace of Partitioning (cont.)
Then search for the first value at the right end of the array that is less than or equal to the pivot value
up down
44 75 23 43 55 12 64 77 33
![Page 147: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/147.jpg)
Trace of Partitioning (cont.)
Exchange these values
up down
44 75 23 43 55 12 64 77 33
![Page 148: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/148.jpg)
Trace of Partitioning (cont.)
Exchange these values
44 33 23 43 55 12 64 77 75
![Page 149: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/149.jpg)
Trace of Partitioning (cont.)
Repeat
44 33 23 43 55 12 64 77 75
![Page 150: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/150.jpg)
Trace of Partitioning (cont.)
Find first value at left end greater than pivot
up
44 33 23 43 55 12 64 77 75
![Page 151: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/151.jpg)
Trace of Partitioning (cont.)
Find first value at right end less than or equal to pivot
up down
44 33 23 43 55 12 64 77 75
![Page 152: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/152.jpg)
Trace of Partitioning (cont.)
Exchange
44 33 23 43 12 55 64 77 75
![Page 153: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/153.jpg)
Trace of Partitioning (cont.)
Repeat
44 33 23 43 12 55 64 77 75
![Page 154: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/154.jpg)
Trace of Partitioning (cont.)
Find first element at left end greater than pivot
up
44 33 23 43 12 55 64 77 75
![Page 155: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/155.jpg)
Trace of Partitioning (cont.)
Find first element at right end less than or equal to pivot
updown
44 33 23 43 12 55 64 77 75
![Page 156: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/156.jpg)
Trace of Partitioning (cont.)
Since down has "passed" up, do not exchange
updown
44 33 23 43 12 55 64 77 75
![Page 157: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/157.jpg)
Trace of Partitioning (cont.)
Exchange the pivot value with the value at down
updown
44 33 23 43 12 55 64 77 75
![Page 158: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/158.jpg)
Trace of Partitioning (cont.)
Exchange the pivot value with the value at down
down
12 33 23 43 44 55 64 77 75
![Page 159: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/159.jpg)
Trace of Partitioning (cont.)
The pivot value is in the correct position; return the value of down
and assign it to the pivot index pivIndex
down
12 33 23 43 44 55 64 77 75
![Page 160: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/160.jpg)
Algorithm for Partitioning
![Page 161: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/161.jpg)
Code for partition when Pivot is the largest or smallest value
![Page 162: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/162.jpg)
Revised Partition Algorithm
¨ Quicksort is O(n2) when each split yields one empty subarray, which is the case when the array is presorted
¨ A better solution is to pick the pivot value in a way that is less likely to lead to a bad split¤ Use three references: first, middle, last¤ Select the median of the these items as the pivot
![Page 163: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/163.jpg)
Trace of Revised Partitioning
44 75 23 43 55 12 64 77 33
![Page 164: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/164.jpg)
Trace of Revised Partitioning (cont.)
44 75 23 43 55 12 64 77 33
middlefirst last
![Page 165: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/165.jpg)
Trace of Revised Partitioning (cont.)
44 75 23 43 55 12 64 77 33
Sort these values
middlefirst last
![Page 166: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/166.jpg)
Trace of Revised Partitioning (cont.)
33 75 23 43 44 12 64 77 55
Sort these values
middlefirst last
![Page 167: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/167.jpg)
Trace of Revised Partitioning (cont.)
33 75 23 43 44 12 64 77 55
Exchange middle with first
middlefirst last
![Page 168: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/168.jpg)
Trace of Revised Partitioning (cont.)
44 75 23 43 33 12 64 77 55
Exchange middle with first
middlefirst last
![Page 169: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/169.jpg)
Trace of Revised Partitioning (cont.)
44 75 23 43 33 12 64 77 55
Run the partition algorithm using the first element as the
pivot
![Page 170: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/170.jpg)
Algorithm for Revised partitionMethod
Algorithm for Revised partition Method
1. Sort table[first], table[middle], and table[last]
2. Move the median value to table[first] (the pivot value) by exchanging table[first] and table[middle].
3. Initialize up to first and down to last
4. do
5. Increment up until up selects the first element greater than the pivot value or up has reached last
6. Decrement down until down selects the first element less than or equal to the pivot value or down has reached first
7. if up < down then
8. Exchange table[up] and table[down]
9. while up is to the left of down
10. Exchange table[first] and table[down]
11. Return the value of down to pivIndex
![Page 171: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/171.jpg)
Summary
Comparison of Sort Algorithms
![Page 172: Merge Quick HeapSort - University of Maryland, College Park · • Merge Sort: O(n log n) • grows more slowly than Q(n2) • asymptotically beats insertion sort in the worst case](https://reader030.vdocument.in/reader030/viewer/2022040608/5ec95e8c918cbb6baa072502/html5/thumbnails/172.jpg)
Sorting Algorithm Comparison172
Name Best Average Worst Memory Stable
Bubble Sort n n2 n2 1 yes
Selection Sort n2 n2 n2 1 no
Insertion Sort n n2 n2 1 yes
Merge Sort nlogn nlogn nlogn n yes
Quick Sort nlogn nlogn n2 log n no
Heap Sort nlogn nlogn nlogn 1 no