1 / 20

CMPT 225

CMPT 225. Lecture 16 – Heap Sort. Last Lecture. We saw how to … Define binary heaps: minimum and maximum Demonstrate and trace their recursive operations Describe Priority Queue Define public interface of Priority Queue ADT

eastmana
Download Presentation

CMPT 225

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. CMPT 225 Lecture 16 – Heap Sort

  2. Last Lecture • We saw how to … • Define binary heaps: minimum and maximum • Demonstrate and trace their recursive operations • Describe Priority Queue • Define public interface of Priority Queue ADT • Design and implement Priority Queue ADT using various data structures • Compare and contrast these various implementations using Big O notation • Give examples of real-life applications (problems) where we could use Priority Queue ADTs to solve the problem • Solve problems using Priority Queue ADT

  3. Learning Outcomes • At the end of the next few lectures, a student will be able to: • Define the following data structures: • Binary search tree • Balanced binary search tree (AVL) • Binary heap as well as demonstrate and trace their operations • Implement the operations of binary search tree and binary heap • Implement and analyze sorting algorithms: tree sort and heap sort • Write recursive solutions to non-trivial problems, such as binary search tree traversalsand heap sort

  4. Today’s menu • Our goal is to • Understand how heap sort works • Sort an array using heap sort • Analyze time/space efficiency of heap sort

  5. Remember Selection Sort • Sorting algorithm in which, at every iteration, we “selected” the smallest (or largest) element of the unsorted section of our array and swap it into the sorted section of our array

  6. Heap Sort • Sorting algorithm in which, at every iteration, we “select” the smallest or min (largest or max) element of the unsorted section of our array and swap it into the sorted section of our array • Use minimum binary heap in order to sort an array of data in descendingorder • Use maximum binary heap in order to sort data in ascendingorder

  7. Overview of Heap Sort Algorithm To sort an array of n elements: • Interpret the array as a binary tree in contiguous storage • Such a tree is always complete • But it may not be a heap • Phase 1: Convert the binary tree (array) into a heap, i.e., heapify! Phase 2: Sort the heap The heap sort algorithm consists of two phases

  8. Heap Sort Algorithm Phase 1 • Let index be the index of the last parent node in the tree • While index >= 0reHeapDown( index)index -- Phase 2 (heap can be seen as the unsorted section of array) • Set counter unsorted to n(unsorted -> size of heap) • Store the last element of the heapinto temporary storage lastElement • Move the root to the last position in the heap • Decrease counter unsortedto exclude the last entry from further sorting (can be seen as the first element in sorted section of array) • Insert lastElementinto root (position now available) • reHeapDown( indexOfRoot ) between positions 0 and unsorted– 1 • Repeat steps 2 to 6 until unsortedis 1 Heapify Sort

  9. ReHeapDown( ) (Min heap) reHeapDown( indexOfRoot) // If the parent has at least a child and … if ( heap[indexOfRoot] is not a leaf ) compute index of children compare the children and pick smallest child set indexOfMinChild to index of smallest child of root // … key value of parent >key value of smallest child then … if ( heap[indexOfRoot] > heap[indexOfMinChild] ) //… swap the parent with its smallest child swap heap[indexOfRoot] with heap[indexOfMinChild] reHeapDown( indexOfMinChild )

  10. ReHeapDown( ) (Max heap) reHeapDown( indexOfRoot ) // If the parent has at least a child and … if ( heap[indexOfRoot] is not a leaf ) compute index of children compare the children and pick largest child set indexOfMaxChildto index of largest child of root // … key value of parent <key value of largest child then … if ( heap[indexOfRoot] < heap[indexOfMaxChild] ) //… swap the parent with its largest child swap heap[indexOfRoot] with heap[indexOfMaxChild] reHeapDown( indexOfMaxChild)

  11. Demo of Heap Sort - 1 • Phase 1

  12. Demo of Heap Sort - 2 n lastElement

  13. Demo of Heap Sort - 3

  14. Let’s try!

  15. Time Complexity Analysis of Heap Sort Phase 1 • O(n) Phase 2 • O( n log2n ) Hence in the worst case the overall time complexity of the heap sort algorithm is: max[ O(n), O( n log2n ) ] = O( n log2n )

  16. Space Complexity Analysis of Heap Sort • How much space (memory) does heap sort require to execute (aside from original data collection)? Therefore, its space efficiency is ->

  17. Heap Sort is not Stable

  18. Careful with Step 1 of Heap Sort • Goal of Step 1 of Heap Sort is to transform an array into a heap • To do so, we could Heapify • Or we could _________________________________________ • Is there a difference?

  19. √ Learning Check • We can now … • Understand how heap sort works • Sort an array using heap sort • Analyze time/space efficiency of heap sort

  20. Next Lecture • Binary Search Tree

More Related