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.

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.

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

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

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

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

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

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

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

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

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

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

QuickSort Example Move Down to the first value <= Pivot 1 2 3 4 5 6 1 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.

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

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

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

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); }

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

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

Heap Sort How can a tree be represented in an array? 12 57 19 12 57 19 1 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

Heap Sort How can a tree be represented in an array? 12 57 19 87 15 44 23 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* 2 + 1 = 3 Right Child (15): ParentPos*2 + 2 = 1 *2 + 2 = 4

Heap Sort How can a tree be represented in an array? 12 57 19 87 15 44 23 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* 2 + 1 = 5 Right Child (15): ParentPos*2 + 2 = 2 *2 + 2 = 6

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.

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)

Heap Sort How to build a heap? 12 1 2 3 4 5 6 12 57 19 87 15 44 23 1 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.

Heap Sort How to build a heap? 12 57 1 2 3 4 5 6 12 57 19 87 15 44 23 1 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

Heap Sort How to build a heap? 57 12 1 2 3 4 5 6 57 12 19 87 15 44 23 1 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.

Heap Sort How to build a heap? 57 12 19 1 2 3 4 5 6 57 12 19 87 15 44 1 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.

Heap Sort How to build a heap? 57 12 19 1 2 3 4 5 6 57 12 19 87 15 44 1 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.

Heap Sort How to build a heap? 57 87 19 1 2 3 4 5 6 57 87 19 12 15 44 1 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

Heap Sort How to build a heap? 87 57 19 1 2 3 4 5 6 87 57 19 12 15 44 1 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.

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

Heap Sort How to build a heap? 87 57 19 1 2 3 4 5 6 87 57 19 12 15 44 1 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.

Heap Sort How to build a heap? 87 57 44 1 2 3 4 5 6 87 57 44 12 15 19 1 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.

Heap Sort How to build a heap? 87 57 44 1 2 3 4 5 6 87 57 44 12 15 19 1 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.

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

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

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

Heap Sort Exchange the root with the last value in the tree 87 57 44 1 1 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

Heap Sort Exchange the root with the last value in the tree 23 57 44 1 1 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

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!

Heap Sort 23 The tree The sorted list 57 44 1 2 3 4 5 6 23 57 44 12 15 1 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!

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

Heap Sort 23 The tree The sorted list 57 44 1 2 3 4 5 6 23 57 44 12 15 1 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”

Heap Sort 57 The tree The sorted list 23 44 1 2 3 4 5 6 57 23 44 12 15 1 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.

Heap Sort 57 The tree The sorted list 23 44 1 2 3 4 5 6 57 23 44 12 15 1 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.

Heap Sort 19 The tree The sorted list 23 44 1 2 3 4 5 6 19 23 44 12 15 1 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.

Heap Sort 19 The tree The sorted list 23 44 1 2 3 4 5 6 19 23 44 12 15 1 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.

Heap Sort 19 The tree The sorted list 23 44 1 2 3 4 5 6 19 23 44 12 15 1 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.

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

Heap Sort 19 The tree The sorted list 23 44 1 2 3 4 5 6 19 23 44 12 15 1 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.

Heap Sort 44 The tree The sorted list 23 19 1 2 3 4 5 6 44 23 19 12 15 1 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Heap Sort 12 The tree The sorted list 1 2 3 4 5 6 12 15 19 23 44 57 87 1 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.

Heap Sort The tree The sorted list 1 2 3 4 5 6 12 15 19 23 44 57 87 1 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.