1 / 22

Priority Queue ADT Binary Heaps

Priority Queue ADT Binary Heaps. Gerda Kamberova Department of Computer Science Hofstra University. Overview. Priority Queue (PQ) ADT definition. Applications Implementation - binary heaps (heaps). Complexity analysis. Priority Queue ADT. Priority Queue (PQ) ADT is a dynamic set

meadow
Download Presentation

Priority Queue ADT Binary Heaps

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. Priority Queue ADTBinary Heaps Gerda Kamberova Department of Computer Science Hofstra University G.Kamberova, Algorithms

  2. Overview • Priority Queue (PQ) ADT definition. • Applications • Implementation - binary heaps (heaps). • Complexity analysis G.Kamberova, Algorithms

  3. Priority Queue ADT • Priority Queue (PQ) ADT is a dynamic set • with keys viewed as priorities • The keys could be compared, so we can identify the element with highest priority • supports • insert • delete element with highest priority • retrieve element with highest priority (without delete) • Depending on what, min or max, is selected as highest priority, we distinguish between min- and max-prioirity queues Historically, PQ means min-PQ. • If x is a reference to a record, the operations on priority queue S are: • For max-priority queue: Max(S), DeleteMax(S), Insert(S,x) • For min-priority queue: Min(S), DeleteMin(S), Insert(S,x) G.Kamberova, Algorithms

  4. Applications • Job scheduling on a multiuser system • Queue (FIFO). Not a good choice. • PQ: • greedy algorithm: let the smallest job run first. • Keep a PQ of incoming jobs and efficiently retrieve the highest priority job to run. • Minimizes avg time to wait • Event-driven discrete-event system simulation: most prevalent application of PQ is in G.Kamberova, Algorithms

  5. PQ ADT Implementation • Linked list (sorted or unsorted)? • Array sorted or unsorted? • Binary search tree (BST)? • O(log n), • overkill, supports all dynamic set operations • Heap • no linked lists • better suited than BST for PQ • Implementation, internally the structure is an array • O(log n) in worst case. • Insert is O(1) on average. • Building PQ is in linear time, O(n) G.Kamberova, Algorithms

  6. Binary Heap (Heap) • Heap (binary heap) is a binary tree (BT) in which the following properties are satisfied: • HS [the heap structure property or heap shape]: the BT is completely filled at all levels except possibly on the very last, where it is filled from left to right • PODR[ the partial order heap order property]: the key value stored at any non-leaf node is >= the key values of its children. • no particular • Note: • order between key values on the same level. • Max is at the root • when you go from a leaf, up a direct path, to the root, the keys are encountered in non-decreasing order. • the operations insert and delete may destroy the heap properties, so these operations should not terminate before restoring the heap properties G.Kamberova, Algorithms

  7. BT Representation of a Max Heap • Check HS and PORD properties 16 10 14 9 8 7 3 2 4 1 G.Kamberova, Algorithms

  8. Implementation of a Heap • since a heap is almost a complete BT, it is easily stored in an array (no need to store pointers): 16 10 14 9 8 7 3 2 4 1 16 14 10 8 7 9 3 2 4 1 … G.Kamberova, Algorithms

  9. Implementation of a Heap Nodes are labeled left-to-right in level order (root first, the right-most leaf last), and this order defines the array indices. 16 10 14 9 8 7 3 2 4 1 Read top to bottom, left to right, fill left to right, start at index 1 Read left to right, fill top to bottom left to right 16 14 10 8 7 9 3 2 4 1 … 1 2 3 4 5 6 7 8 9 10 G.Kamberova, Algorithms

  10. Implementation of the PQ operations with heaps • Retrieve the maximum • Easy, just return the root • Insert/DeleteMax • more complicated. • Must preserve HS and PORD properties. • Insert: • Input: a heap A of size n and an element referenced by x with key k to be inserted. • Output: A heap A of size n+1. • Where to place the new node? • not much choice, must preserve HS. • create a new node at index n+1 • If we place the new key at that place the PROD may be destroyed. • restore PORD by sifting up the new node until it falls in place i.e. where the new key will be in place G.Kamberova, Algorithms

  11. Insertion in a max heap: Example • Insert element with key 15 in the heap • Create a new node as most right leaf in tree • Propagate “hole” up until it falls in place 16 10 14 14 9 8 7 3 7 2 4 1 15 G.Kamberova, Algorithms

  12. Insertion in a heap • Implementation • Create the (n+1)-st node, and sift the key upwards Heap_Insert(A, key, n) n = n+1 i = n // find the spot for the new key while (i > 1 && A(Parent[i]) < key ) A[i] = A[Parent(i)] i = Parent(i) A[i] = key • Complexity: G.Kamberova, Algorithms

  13. Delete in a heap • Input: Heap A of size n; • Output: Heap A of size n-1, the root key value is removed from the heap (may be returned as well) • Since the heap HS must be preserved, the output heap is missing the right-most leaf of the input heap. • The root value must be extracted, and the “hole” at the root must be filled in • This suggest the following procedure: • copy the key from right-most leaf to root • delete right-most leaf • Restore PORD: heapify G.Kamberova, Algorithms

  14. Delete in a heap Heap_Delete(A, n) A[1] = A[n] //copy last leaf in root n = n - 1 Heapify(A,1) G.Kamberova, Algorithms

  15. Deletion from the heap 1 Heap_Delete(A, n) A[1] = A[n] //copy last leaf in root n = n - 1 Heapify(A,1) • Complexity: O(1)+ time to heapify 16 10 14 9 8 7 3 2 4 1 G.Kamberova, Algorithms

  16. Heapify • Input: A rooted tree, such that A[i] is at the root, and the left and the right subtrees (if exist) are heaps. • Output: The tree is made into a heap. • Procedure: • Sift down the key value of the root until it falls in place. • a recursive procedure: • compare key at the root with the keys of its children. • If the root key >= of the children keys, stop, • Otherwise, swap root key with the key of larger child, and proceed in hipifying now the subtree rooted at the node for which swap occured G.Kamberova, Algorithms

  17. Heapify • Hipify(A,i) : makes the subtree rooted at A[i] into a heap, provided that the trees rooted at A[Left(i)] and A[Right(i)] are heaps. Hipify(A,i) if A[i] is smaller than its children m = index of larger child swap A[i] and A[m] Hipify(A,m) G.Kamberova, Algorithms

  18. Deletion from the heap: Example 1 16 10 14 9 8 7 3 2 4 1 G.Kamberova, Algorithms

  19. Deletion from the heap: Example • Complexity: if we swap, iteratively, bounded by the heigh • Complexity using recursive heapify? 1 10 14 9 8 7 3 2 4 G.Kamberova, Algorithms

  20. Complexity of Heapify • Worst case: at each recursive call the subtree on which the call is made on a complete BT (all leaves at last level exist); the height of that tree must be one more than the height of the other subtree • In a complete BT the number of leaves is equal half of the nodes • If the worst-case tree has n nodes, they are distributed as follows • Recurrence for Heapify n/3 n/3 n/3 G.Kamberova, Algorithms

  21. Constructing a heap • Top-down: using HeapInsert, • successively insert nodes staring with an empty heap. • Time complexity is O(nlog n) • Bottom-up: using Heapify • Construct an almost complete binary tree with n vertices and store the keys arbitrarily there. This is Theta(n) • Now going bottom up, from the most right node in the last internal level, heapify the trees rooted at the internal nodes. • This time can be shown to be linear O(n) G.Kamberova, Algorithms

  22. Heapsort • Build a heap: O(n) or O(n log n) • Do n times extract_max n times: O(n log n) • Total time O(n log n) G.Kamberova, Algorithms

More Related