1 / 25

Understanding Priority Queues and Heaps in Data Structures

Learn about Priority Queues and Heaps, their operations, implementations like Binary Heap, AVL Tree, and more.

pmatthews
Download Presentation

Understanding Priority Queues and Heaps in Data Structures

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. Lecture 15: Intro to Heaps CSE 373 Data Structures and Algorithms CSE 373 SP 18 - Kasey Champion CSE 373 19 SP - Kasey Champion

  2. Administrivia • Midterm grades out later this week • HW 4 due Wednesday night • HW 5 out Wednesday (partner project) CSE 373 SP 18 - Kasey Champion

  3. Heaps CSE 373 SP 18 - Kasey Champion

  4. Priority Queue ADT Max Priority Queue ADT Min Priority Queue ADT Imagine you have a collection of data from which you will always ask for the extreme value If a Queue is “First-In-First-Out” (FIFO) Priority Queues are “Most-Important-Out-First” Example: Triage, patient in most danger is treated first Items in Queue must be comparable, Queue manages internal sorting state state Set of comparable values - Ordered based on “priority” Set of comparable values - Ordered based on “priority” behavior behavior removeMin() – returns the element with the smallest priority, removes it from the collection removeMax() – returns the element with the largest priority, removes it from the collection peekMax() – find, but do not remove the element with the largest priority peekMin() – find, but do not remove the element with the smallest priority insert(value) – add a new element to the collection insert(value) – add a new element to the collection CSE 373 SP 18 - Kasey Champion

  5. Let’s start with an AVL tree O(logn) • What is the worst case for peekMin()? • What is the best case for peekMin()? • Can we do something to guarantee best case for removeMin() and peekMin()? AVLPriorityQueue<E> state overallRoot O(logn) behavior removeMin() – traverse through tree all the way to the left, remove node, rebalance if necessary peekMin() – traverse through tree all the way to the left insert() – traverse through tree, insert node in open space, rebalance as necessary CSE 373 19 SP - Kasey Champion

  6. Binary Heap 2 36 3 22 10 10 7 5 6 8 9 2 3 1 1 4 9 4 5 8 47 • A type of tree with new set of invariants • 1. Binary Tree: every node has at most 2 children • 2. Heap: every node is smaller than its child 3. Structure: Each level is “complete” meaning it has no “gaps” - Heaps are filled up left to right CSE 373 SP 18 - Kasey Champion

  7. Self Check - Are these valid heaps? 3 Minutes 7 8 10 2 5 7 4 6 5 4 3 1 6 9 7 11 8 9 3 INVALID Binary Heap Invariants: Binary Tree Heap Complete VALID INVALID CSE 373 SP 18 - Kasey Champion

  8. Implementing peekMin() 10 11 9 4 5 7 2 13 8 Runtime: O(1) CSE 373 SP 18 - Kasey Champion

  9. Implementing removeMin() 10 10 11 11 9 9 13 7 5 4 7 5 4 2 13 8 8 1.) Return min 2.) replace with last added Structure maintained, heap broken CSE 373 SP 18 - Kasey Champion • Runtime: • Locating min = O(1) • Fixing heap = ? • Removing overallRoot creates a gap • Replacing with one of its children causes lots of gaps • What node can we replace with overallRoot that wont cause any gaps?

  10. Implementing removeMin() - percolateDown 10 11 9 13 5 7 4 8 3.) percolateDown() Recursively swap parent with smallest child 4 5 13 13 11 13 CSE 373 SP 18 - Kasey Champion • Runtime: • Locating min = O(1) • Fixing heap = ? • Removing overallRoot creates a gap • Replacing with one of its children causes lots of gaps • What node can we replace with overallRoot that wont cause any gaps?

  11. 3 Minutes Practice: removeMin() 11 5 22 15 24 20 18 16 19 9 13 17 14 10 18 9 18 11 18 CSE 373 SP 18 - Kasey Champion

  12. Implementing insert() 10 11 9 3 5 4 7 2 13 8 • Algorithm: • Insert a node to ensure no gaps • Fix heap invariant • percolate UP 3 4 3 8 CSE 373 19 SP - Kasey Champion

  13. 3 Minutes Practice: Building a minHeap 20 2 7 • Construct a Min Binary Heap by inserting the following values in this order: • 5, 10, 15, 20, 7, 2 Min Priority Queue ADT state Min Binary Heap Invariants Binary Tree – each node has at most 2 children Min Heap – each node’s children are larger than itself Level Complete - new nodes are added from left to right completely filling each level before creating a new one Set of comparable values - Ordered based on “priority” behavior removeMin() – returns the element with the smallest priority, removes it from the collection 5 2 peekMin() – find, but do not remove the element with the smallest priority 15 10 5 7 2 insert(value) – add a new element to the collection percolateUp! 10 15 percolateUp! percolateUp! CSE 373 SP 18 - Kasey Champion

  14. minHeap runtimes • removeMin(): • Find and remove minimum node • Find last node in tree and swap to top level • Percolate down to fix heap invariant • insert(): • Insert new node into next available spot • Percolate up to fix heap invariant CSE 373 SP 18 - Kasey Champion

  15. Implementing Heaps How do we find the minimum node? How do we find the last node? How do we find the next open space? How do we find a node’s left child? How do we find a node’s right child? How do we find a node’s parent? H K J L G I A B D C E F Fill array in level-order from left to right CSE 373 19 SP - Kasey Champion

  16. Heap Implementation Runtimes char peekMin() timeToFindMin Tree Array char removeMin() findLastNodeTime + removeRootTime + numSwaps * swapTime Tree Array void insert(char) findNextSpace + addValue + numSwaps * swapTime Tree Array Θ(1) D F E Θ(1) B C A Θ(n) n + 1 + log(n) * 1 Θ(log(n)) 1 + 1 + log(n) * 1 Θ(n) n + 1 + log(n) * 1 Θ(log(n)) 1 + 1 + log(n) * 1 CSE 373 SP 18 - Kasey Champion

  17. Building a Heap • Insert has a runtime of Θ(log(n)) • If we want to insert a n items… • Building a tree takes O(nlog(n)) • Add a node, fix the heap, add a node, fix the heap • Can we do better? • Add all nodes, fix heap all at once! CSE 373 SP 18 - Kasey Champion

  18. Cleaver building a heap – Floyd’s Method • Facts of binary trees • Increasing the height by one level doubles the number of possible nodes • A complete binary tree has half of its nodes in the leaves • A new piece of data is much more likely to have to percolate down to the bottom than be the smallest element in heap • 1. Dump all the new values into the bottom of the tree • Back of the array • 2. Traverse the tree from bottom to top • Reverse order in the array • 3. Percolate Down each level moving towards overall root CSE 373 SP 18 - Kasey Champion

  19. Floyd’s buildHeap algorithm Build a tree with the values: 12, 5, 11, 3, 10, 2, 9, 4, 8, 15, 7, 6 Add all values to back of array percolateDown(parent) starting at last index 6 15 7 9 4 8 12 5 2 3 11 10 15 12 5 11 3 10 2 9 4 8 7 6 CSE 373 SP 18 - Kasey Champion

  20. Floyd’s buildHeap algorithm Build a tree with the values: 12, 5, 11, 3, 10, 2, 9, 4, 8, 15, 7, 6 • Add all values to back of array • percolateDown(parent) starting at last index • percolateDown level 4 • percolateDown level 3 4 7 15 6 9 8 7 2 11 10 5 3 12 10 12 5 11 3 10 2 9 4 8 7 6 15 CSE 373 SP 18 - Kasey Champion

  21. Floyd’s buildHeap algorithm Build a tree with the values: 12, 5, 11, 3, 10, 2, 9, 4, 8, 15, 7, 6 • Add all values to back of array • percolateDown(parent) starting at last index • percolateDown level 4 • percolateDown level 3 • percolateDown level 2 3 2 4 7 6 15 9 8 6 7 5 11 2 10 12 3 11 5 keep percolating down like normal here and swap 5 and 4 11 10 12 5 3 9 4 8 6 11 7 15 2 10 CSE 373 SP 18 - Kasey Champion

  22. Floyd’s buildHeap algorithm Build a tree with the values: 12, 5, 11, 3, 10, 2, 9, 4, 8, 15, 7, 6 2 • Add all values to back of array • percolateDown(parent) starting at last index • percolateDown level 4 • percolateDown level 3 • percolateDown level 2 • percolateDown level 1 3 2 12 6 9 15 7 5 8 7 4 6 2 12 5 3 11 10 10 11 12 3 9 5 8 15 4 2 11 6 10 7 CSE 373 SP 18 - Kasey Champion

  23. Floyd’s buildHeap algorithm Build a tree with the values: 12, 5, 11, 3, 10, 2, 9, 4, 8, 15, 7, 6 2 • Add all values to back of array • percolateDown(parent) starting at last index • percolateDown level 4 • percolateDown level 3 • percolateDown level 2 • percolateDown level 1 3 2 6 9 6 15 7 5 8 7 4 6 11 3 11 10 2 5 12 10 11 12 3 11 9 5 8 6 2 15 4 12 10 7 CSE 373 SP 18 - Kasey Champion

  24. Floyd’s Heap Runtime • We step through each node – n • We call percolateDown() on each n – log n • thus it’s O(nlogn) • … let’s look closer… • Are we sure percolateDown() runs log n each time? • Half the nodes of the tree are leaves • Leaves run percolate down in constant time • ¼ the nodes have at most 1 level to travel • 1/8 the nodes have at most 2 levels to travel • etc… • work(n) ≈ n/2 * 1 + n/4 * 2 + n/8 * 3 + … CSE 373 SP 18 - Kasey Champion

  25. Closed form Floyd’s buildHeap • work(n) ≈ * 1 + * 2 + * 3 + … factor out n work(n) ≈ n( + + + …) work(n) ≈ n( + + + …) find a pattern -> powers of 2 Summation! ? = how many levels = height of tree = log(n) Infinite geometric series Floyd’s buildHeap runs in O(n) time! CSE 373 SP 18 - Kasey Champion

More Related