1 / 77

QuickSort

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

wbiller
Download Presentation

QuickSort

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

E N D

Presentation Transcript

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

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

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

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

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

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

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

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

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

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

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

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

  16. 12 33 23 43 44 55 64 77 75 QuickSort Example This gives us two new subarrays to Partition 0 1 2 7 8 3 4 5 6 Pivot 44 First2 Last1 First1 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. 0 1 2 3 4 5 6 Heap Sort How can a tree be represented in an array? 12 19 57 87 15 44 23

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

  20. 0 1 2 3 4 5 6 12 57 19 Heap Sort How can a tree be represented in an array? 12 19 57 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. 12 19 57 0 1 2 3 4 5 6 87 15 44 23 12 57 19 87 15 Heap Sort How can a tree be represented in an array? 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

  22. 12 19 57 87 15 44 23 12 57 19 87 15 Heap Sort How can a tree be represented in an array? 0 1 2 3 4 5 6 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

  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. 12 12 57 19 87 15 Heap Sort How to build a heap? 0 1 2 3 4 5 6 44 23 Add Table[0] to tree Since it has no parent, we have a heap.

  26. 12 12 57 19 87 15 Heap Sort How to build a heap? 57 0 1 2 3 4 5 6 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. 57 57 12 19 87 15 Heap Sort How to build a heap? 12 0 1 2 3 4 5 6 44 23 Exchange Since 57 >12 57 is as high as it can go, so we have a heap.

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

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

  30. 57 57 87 19 12 15 Heap Sort How to build a heap? 87 19 0 1 2 3 4 5 6 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. 87 87 57 19 12 15 Heap Sort How to build a heap? 57 19 0 1 2 3 4 5 6 44 23 12 Again 87 > 57, so not a heap. Bubble it up. Exchange. We now have a heap again.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

More Related