1. QuickSort QuickSort is often called Partition Sort.
It is a recursive method, in which the unsorted array is first
rearranged so that there is some record, somewhere in the
middle of the array, whose key is greater than all the keys
to its left & less than or equal to all the keys to its right.
Once this “middle is found, the same method can be used to sort the section of the array to the left, then sort the section to the right.

2. QuickSort Algorithm 1. If First < Last then
2. Partition the elements in the array (First, Last) so that
the pivot value is in place ( position PivIndex).
3. Apply QuickSort to the first subarray (First, PivIndex -1)
4. Apply QuickSort to the second subarray (PivIndex + 1, Last).
The two stopping Cases are:
1. (First = Last) - only one value in subarray, so sorted.
2. (First > Last) - no values in subarray, so sorted.

3. How do we Partition?
1. Define the pivot value as the content of Table[First]
2. Initialize Up to First and Down to last
3. Repeat
4. Increment Up until Up selects the first element greater
than the pivot value
5. Decrement Down until it selects the first element less
than or equal to the pivot value.
6. If Up < Down exchange their values.
Until Up meets or passes Down.
7. Exchange Table[First] and Table[Down]
8. Define PivIndex as Down

4. QuickSort Example Has First exceeded Last? No!
Define the value in position First to be the Pivot. 44 75 23 64 33 12 43 77 55 1 2 3 4 5 6 7 8
First
Last
Pivot 44

5. QuickSort Example Define Up To be First and Down to be last 1 2 3 4 51 2 3 4 5 6 7 8
Pivot 44 44 75 23 64 33 12 43 77 55
First
Down Up
Last

6. QuickSort Example Move Up to the first value > Pivot 1 2 3 4 5 6 71 2 3 4 5 6 7 8
Pivot 44 44 75 23 64 33 12 43 77 55
First Up
Down
Last

7. QuickSort Example Move Down to the first value <= Pivot 1 2 3 4 5 61 2 3 4 5 6 7 8
Pivot 44 44 75 23 64 33 12 43 77 55
First Up
Down
Last

8. QuickSort Example If Up < Down, exchange their values 1 2 3 4 5 6 71 2 3 4 5 6 7 8
Pivot 44 44 33 23 64 75 12 43 77 55
First Up
Down
Last

9. QuickSort Example Move Up to the first value > Pivot 1 2 3 4 5 6 71 2 3 4 5 6 7 8
Pivot 44 44 33 23 64 75 12 43 77 55
First
Down
Last Up

10. QuickSort Example Move Down to the first value <= Pivot 1 2 3 4 5 61 2 3 4 5 6 7 8
Pivot 44 44 33 23 64 75 12 43 77 55
First
Last Up
Down

11. QuickSort Example If Up < Down, exchange their values. 1 2 3 4 5 61 2 3 4 5 6 7 8
Pivot 44 44 33 23 64 75 55 43 77 12
First
Last Up
Down

12. QuickSort Example Move Up to the first value > Pivot 1 2 3 4 5 6 71 2 3 4 5 6 7 8
Pivot 44 44 33 23 64 75 55 43 77 12
First
Last Up
Down

13. QuickSort Example Move Down to the first value <= Pivot 1 2 3 4 5 61 2 3 4 5 6 7 8
Pivot 44 44 33 23 64 75 55 43 77 12
First
Last Up
Down
Up and Down have passed each other, so exchange the pivot
value and the value in Down.

14. QuickSort Example Up and Down have passed each other, so exchange
the pivot value and the value in Down. 1 2 3 4 5 6 7 8
Pivot 44 12 33 23 64 75 55 43 77 44
First
Last Up
Down

15. QuickSort Example
Note that all values below PivIndex are <= Pivot and
all values above PivIndex are > Pivot. 12 33 23 64 75 55 43 77 44 1 2 3 4 5 6 7 8
Pivot 44
First
Last
PivIndex

16. QuickSort Example This gives us two new subarrays to Partition 1 2 3 41 2 3 4 5 6 7 8
Pivot 44 12 33 23 64 75 55 43 77 44
First2
First1
Last1
Last2
PivIndex

17. QuickSort Procedure Code
void QuickSort(int Table[], int First, int Last) {
int PivIndex;
if (First < Last)
PivIndex = Partition(Table, First, Last);
QuickSort(Table, First, PivIndex - 1);
QuickSort(Table, PivIndex + 1, Last); }

18. Heap Sort How can a tree be represented in an array? 12 57 19 1 2 3 41 2 3 4 5 6 87 15 44 23

19. Heap Sort How can a tree be represented in an array? 12 57 19 12 1 2 31 2 3 4 5 6 87 15 44 23
Place the root of the tree in element 0 of the array (RootPos = 0).

20. Heap Sort How can a tree be represented in an array? 12 57 19 12 57 191 2 3 4 5 6 87 15 44 23
Place the root of the tree in element 0 of the array (RootPos = 0).
Place the root’s left child in element 1 : (RootPos*2 + 1) = 1
Place the root’s right child in element 2: (RootPos*2 + 2) = 2

21. Heap Sort How can a tree be represented in an array? 12 57 19 87 15 4423 12 57 19 87 15 1 2 3 4 5 6
Place the root of the tree in element 0 of the array (RootPos = 0).
Place the root’s left child in element 1 : (RootPos*2 + 1)
Place the root’s right child in element 2: (RootPos*2 + 2)
The Children of 57 are placed in:
Left Child (87): ParentPos*2 +1 = 1* = 3
Right Child (15): ParentPos*2 + 2 = 1 *2 + 2 = 4

22. Heap Sort How can a tree be represented in an array? 12 57 19 87 15 4423 1 2 3 4 5 6 12 57 19 87 15 44 23
Place the root of the tree in element 0 of the array (RootPos = 0).
Place the root’s left child in element 1 : (RootPos*2 + 1)
Place the root’s right child in element 2: (RootPos*2 + 2)
The Children of 19 are placed in:
Left Child (44): ParentPos*2 +1 = 2* = 5
Right Child (15): ParentPos*2 + 2 = 2 *2 + 2 = 6

23. Heap Sort To perform the heap sort we must: 1. Create a heap
(a tree with all nodes greater than their children)
2. Remove the root element from the heap one at a time,
recomposing the heap.

24. Building the Heap 1. For each value in the array(0, n)
2. Place the value into the “tree”
3. Bubble the value as high as it can go
(push the largest values to highest position)

25. Heap Sort How to build a heap? 12 1 2 3 4 5 6 12 57 19 87 15 44 231 2 3 4 5 6 12 57 19 87 15 44 23
Add Table[0] to tree
Since it has no parent, we have a heap.

26. Heap Sort How to build a heap? 12 57 1 2 3 4 5 6 12 57 19 87 15 44 231 2 3 4 5 6 12 57 19 87 15 44 23
Add Table[1] to tree
Since 12 < 57, it is not a heap.
Bubble it up as high as it can go. Exchange

27. Heap Sort How to build a heap? 57 12 1 2 3 4 5 6 57 12 19 87 15 44 231 2 3 4 5 6 57 12 19 87 15 44 23
Exchange
Since 57 >12
57 is as high as it can go, so we have a heap.

28. Heap Sort How to build a heap? 57 12 19 1 2 3 4 5 6 57 12 19 87 15 441 2 3 4 5 6 57 12 19 87 15 44 23
Add Table[2] to tree
Since 57 >19
so, we have a heap.

29. Heap Sort How to build a heap? 57 12 19 1 2 3 4 5 6 57 12 19 87 15 441 2 3 4 5 6 57 12 19 87 15 44 23 87
Add Table[3] to tree
Since 87 >12
so, not a heap.

30. Heap Sort How to build a heap? 57 87 19 1 2 3 4 5 6 57 87 19 12 15 441 2 3 4 5 6 57 87 19 12 15 44 23 12
Add Table[3] to tree
Since 87 >12
so, not a heap. Bubble it up. Exchange.
Again 87 > 57, so not a heap. Bubble it up

31. Heap Sort How to build a heap? 87 57 19 1 2 3 4 5 6 87 57 19 12 15 441 2 3 4 5 6 87 57 19 12 15 44 23 12
Again 87 > 57, so not a heap. Bubble it up.
Exchange.
We now have a heap again.

32. Heap Sort How to build a heap? 87 57 19 1 2 3 4 5 6 87 57 19 12 15 441 2 3 4 5 6 87 57 19 12 15 44 23 12 15
Add Table[4] to tree
15 > 57, so a heap.

33. Heap Sort How to build a heap? 87 57 19 1 2 3 4 5 6 87 57 19 12 15 441 2 3 4 5 6 87 57 19 12 15 44 23 12 15 44
Add Table[5] to tree
44 > 19, so not a heap.

34. Heap Sort How to build a heap? 87 57 44 1 2 3 4 5 6 87 57 44 12 15 191 2 3 4 5 6 87 57 44 12 15 19 23 12 15 19
44 > 19, so not a heap.
Bubble it up. Exchange.
44<87
Again we have a heap.

35. Heap Sort How to build a heap? 87 57 44 1 2 3 4 5 6 87 57 44 12 15 191 2 3 4 5 6 87 57 44 12 15 19 23 12 15 19 23
Add Table[6] to tree
23 <44
so, we have a heap.

36. Heap Sort How to build a heap? The whole table is now a heap! 87 57 441 2 3 4 5 6 19 87 57 44 12 15 23 12 15 19 23
The whole table is now a heap!

37. Heap Sort Algorithm 1. Repeat n -1 times
2. Exchange the root value with the last value in the tree
3. “Drop” the last value from the tree
4. Reform the heap
5. Start at the root node of the current tree
6. If the root is larger than its children, stop- you have a heap.
7. If not, exchange the root with the largest child.
8. Consider this child to be the current root and repeat step 4

38. Heap Sort Here is the heap! 87 57 44 1 2 3 4 5 6 87 57 44 12 15 19 231 2 3 4 5 6 87 57 44 12 15 19 23 12 15 19 23
Here is the heap!

39. Heap Sort Exchange the root with the last value in the tree 87 57 44 11 2 3 4 5 6 87 57 44 12 15 19 23 12 15 19 23
Exchange the root with the last value in the tree

40. Heap Sort Exchange the root with the last value in the tree 23 57 44 11 2 3 4 5 6 23 57 44 12 15 19 87 12 15 19 87
Exchange the root with the last value in the tree

41. Heap Sort 23 57 44 1 2 3 4 5 6 23 57 44 12 15 19 87 12 15 19 87
Drop this last value from the tree -- it is now in the array in
its sorted position!

42. Heap Sort 23 The tree The sorted list 57 44 1 2 3 4 5 6 23 57 44 12 151 2 3 4 5 6 23 57 44 12 15 19 87 12 15 19
Drop this last value from the tree -- it is now in the array in
its sorted position!

43. Heap Sort 23 The tree The sorted list 57 44 1 2 3 4 5 6 23 57 44 12 151 2 3 4 5 6 23 57 44 12 15 19 87 12 15 19
Reform the heap

44. Heap Sort 23 The tree The sorted list 57 44 1 2 3 4 5 6 23 57 44 12 151 2 3 4 5 6 23 57 44 12 15 19 87 12 15 19
Find the largest child of the current “root”
and exchange with “root”

45. Heap Sort 57 The tree The sorted list 23 44 1 2 3 4 5 6 57 23 44 12 151 2 3 4 5 6 57 23 44 12 15 19 87 12 15 19
Now 23 is larger than both of its children
so we have a heap again.

46. Heap Sort 57 The tree The sorted list 23 44 1 2 3 4 5 6 57 23 44 12 151 2 3 4 5 6 57 23 44 12 15 19 87 12 15 19
Exchange the root of the heap with the last value in the tree.

47. Heap Sort 19 The tree The sorted list 23 44 1 2 3 4 5 6 19 23 44 12 151 2 3 4 5 6 19 23 44 12 15 57 87 12 15 57
Exchange the root of the heap with the last value in the tree.

48. Heap Sort 19 The tree The sorted list 23 44 1 2 3 4 5 6 19 23 44 12 151 2 3 4 5 6 19 23 44 12 15 57 87 12 15 57
Drop the last element from the tree since the value is now
in its sorted position.

49. Heap Sort 19 The tree The sorted list 23 44 1 2 3 4 5 6 19 23 44 12 151 2 3 4 5 6 19 23 44 12 15 57 87 12 15
Drop the last element from the tree since the value is now
in its sorted position.

50. Heap Sort 19 The tree The sorted list 23 44 1 2 3 4 5 6 19 23 44 12 151 2 3 4 5 6 19 23 44 12 15 57 87 12 15
Reform the heap

51. Heap Sort 19 The tree The sorted list 23 44 1 2 3 4 5 6 19 23 44 12 151 2 3 4 5 6 19 23 44 12 15 57 87 12 15
Find the largest child of the current “root”.
Exchange the values.

52. Heap Sort 44 The tree The sorted list 23 19 1 2 3 4 5 6 44 23 19 12 151 2 3 4 5 6 44 23 19 12 15 57 87 12 15
Since 19 has no children, we now have a heap again.

53. Heap Sort 44 The tree The sorted list 23 19 1 2 3 4 5 6 44 23 19 12 151 2 3 4 5 6 44 23 19 12 15 57 87 12 15
Swap the root with the last position in the tree.

54. Heap Sort 15 The tree The sorted list 23 19 1 2 3 4 5 6 15 23 19 12 441 2 3 4 5 6 15 23 19 12 44 57 87 12 44
Drop the last value from the tree.

55. Heap Sort 15 The tree The sorted list 23 19 1 2 3 4 5 6 15 23 19 12 441 2 3 4 5 6 15 23 19 12 44 57 87 12
Drop the last value from the tree.

56. Heap Sort 15 The tree The sorted list 23 19 1 2 3 4 5 6 15 23 19 12 441 2 3 4 5 6 15 23 19 12 44 57 87 12
Reform the heap by exchanging the root with its largest child

57. Heap Sort 23 The tree The sorted list 15 19 1 2 3 4 5 6 23 15 19 12 441 2 3 4 5 6 23 15 19 12 44 57 87 12
Reform the heap by exchanging the root with its largest child

58. Heap Sort 23 The tree The sorted list 15 19 1 2 3 4 5 6 23 15 19 12 441 2 3 4 5 6 23 15 19 12 44 57 87 12
Exchange the root with the last value in the tree

59. Heap Sort 12 The tree The sorted list 15 19 1 2 3 4 5 6 12 15 19 23 441 2 3 4 5 6 12 15 19 23 44 57 87 23
Exchange the root with the last value in the tree

60. Heap Sort 12 The tree The sorted list 15 19 1 2 3 4 5 6 12 15 19 23 441 2 3 4 5 6 12 15 19 23 44 57 87 23
Drop the last value from the tree

61. Heap Sort 12 The tree The sorted list 15 19 1 2 3 4 5 6 12 15 19 23 441 2 3 4 5 6 12 15 19 23 44 57 87
Drop the last value from the tree

62. Heap Sort 12 The tree The sorted list 15 19 1 2 3 4 5 6 12 15 19 23 441 2 3 4 5 6 12 15 19 23 44 57 87
Reform the heap

63. Heap Sort 12 The tree The sorted list 15 19 1 2 3 4 5 6 12 15 19 23 441 2 3 4 5 6 12 15 19 23 44 57 87
Exchange the root with the largest child

64. Heap Sort 19 The tree The sorted list 15 12 1 2 3 4 5 6 19 15 12 23 441 2 3 4 5 6 19 15 12 23 44 57 87
We have a heap

65. Heap Sort 19 The tree The sorted list 15 12 1 2 3 4 5 6 19 15 12 23 441 2 3 4 5 6 19 15 12 23 44 57 87
Exchange the root with the last position in the tree

66. Heap Sort 12 The tree The sorted list 15 19 1 2 3 4 5 6 12 15 19 23 441 2 3 4 5 6 12 15 19 23 44 57 87
Exchange the root with the last position in the tree

67. Heap Sort 12 The tree The sorted list 15 19 1 2 3 4 5 6 12 15 19 23 441 2 3 4 5 6 12 15 19 23 44 57 87
Drop the last value from the tree

68. Heap Sort 12 The tree The sorted list 15 1 2 3 4 5 6 12 15 19 23 44 571 2 3 4 5 6 12 15 19 23 44 57 87
Drop the last value from the tree

69. Heap Sort 12 The tree The sorted list 15 1 2 3 4 5 6 12 15 19 23 44 571 2 3 4 5 6 12 15 19 23 44 57 87
Reform the heap

70. Heap Sort 12 The tree The sorted list 15 1 2 3 4 5 6 12 15 19 23 44 571 2 3 4 5 6 12 15 19 23 44 57 87
Exchange the root with the largest child

71. Heap Sort 15 The tree The sorted list 12 1 2 3 4 5 6 15 12 19 23 44 571 2 3 4 5 6 15 12 19 23 44 57 87
We have a heap

72. Heap Sort 15 The tree The sorted list 12 1 2 3 4 5 6 15 12 19 23 44 571 2 3 4 5 6 15 12 19 23 44 57 87
Exchange the root with the last value in the tree

73. Heap Sort 12 The tree The sorted list 15 1 2 3 4 5 6 12 15 19 23 44 571 2 3 4 5 6 12 15 19 23 44 57 87
Exchange the root with the last value in the tree

74. Heap Sort 12 The tree The sorted list 15 1 2 3 4 5 6 12 15 19 23 44 571 2 3 4 5 6 12 15 19 23 44 57 87
Drop the last value from the tree

75. Heap Sort 12 The tree The sorted list 1 2 3 4 5 6 12 15 19 23 44 57 871 2 3 4 5 6 12 15 19 23 44 57 87
Drop the last value from the tree

76. Heap Sort 12 The tree The sorted list 1 2 3 4 5 6 12 15 19 23 44 57 871 2 3 4 5 6 12 15 19 23 44 57 87
The tree consists of a single value at this point which is in its
proper place within the sorted list.

77. Heap Sort The tree The sorted list 1 2 3 4 5 6 12 15 19 23 44 57 871 2 3 4 5 6 12 15 19 23 44 57 87
The tree consists of a single value at this point which is in its
proper place within the sorted list.
The array is sorted.