Data Structures and Algorithms

Transcription

1 Berner Fachhochschule - Technik und Informatik Data Structures and Algorithms Heaps and Priority Queues Philipp Locher FS 2018 Heaps and Priority Queues Page 1

2 Outline Heaps Heap-Sort Priority Queues Heaps and Priority Queues Page 2

3 Outline Heaps Heap-Sort Priority Queues Heaps and Priority Queues Page 3

4 The Heap ADT A heap is a specialized binary tree with the following properties: Heap-Order: element(parent(p)) element(p), for every node p other than the root Completeness: let h be the height of the tree 1) there are 2 i nodes of depth i for i = 0,..., h 1 2) at depth h, nodes are filled up from the left The last node of a heap is the rightmost node of depth h Heap operations: insertelement(e): inserts an element e into the heap removemin(): removes smallest elelemt and returns it minelement(): returns the smallest element (no removal) Heaps and Priority Queues Page 4

5 Heap Example 2 6 Depth Last node 4 A heap storing n elements has height O(log n) Heaps and Priority Queues Page

6 Total Order Elements in a heap can be arbitrary objects on which a total order is defined Mathematically, a total order is a binary relation defined on a set X which satisfies three properties: Totality: x y or y x, for all x, y X Antisymmetry: x y and y x implies x = y, for all x, y X Transitivity: x y and y z implies x z, for all x, y, z X Totality implies Reflexivity: x x, for all x X Examples: or for R, alphabetical or reverse alphabetical order for {A,..., Z}, lexicographical order for {A,..., Z}, etc. Heaps and Priority Queues Page 6

7 Comparator ADT A comparator encapsulates the action of comparing two keys according to a given total order relation A generic priority queue uses an auxiliary comparator (passed as a parameter to the constructor) When the priority queue needs to compare two keys, it uses its comparator Operations (all with Boolean return type): islessthan(x,y) islessthanorequalto(x,y) isequalto(x,y) isgreaterthan(x,y) isgreaterthanorequalto(x,y) iscomparable(x) Heaps and Priority Queues Page 7

8 Insertion to a Heap The insertion of an element e consists of 3 steps: Add a new node q (the new last node) Store e at q Restore the heap order property (discussed next) 2 q Heaps and Priority Queues Page 8

9 Upheap Algorithm upheap restores the heap-order property Swap e along an upward path from the insertion node Stop when e reaches the root or a node whose parent has an element smaller than or equal to e Since the height of the heap is O(log n), upheap runs in O(log n) time insertelement(e) runs in O(log n) time Heaps and Priority Queues Page 9

10 Removal from a Heap The removal algorithm consists of 4 steps: Return the element of the root Replace the root element with the element e of the last node Delete the last node Restore the heap order property (discussed next) Last node 7 6 Heaps and Priority Queues Page 10

11 Downheap Algorithm downheap restores the heap-order property Swap e along an downward path from the root (always with the smaller element of its children) Stop when e reaches a leaf or a node whose children have elements greater than or equal to e Since the height of the heap is O(log n), downheap runs in O(log n) time removemin() runs in O(log n) time Heaps and Priority Queues Page 11

12 Finding the Insertion Node Starting from the last node, the insertion node can be found by traversing a path of O(log n) nodes If the last node is a left child, return the parent node While the current node is a right child, go to the parent node If the current node is a left child, go to its (right) sibling While the current node is internal, go to the left child Last node Insertion node Heaps and Priority Queues Page 12

13 Array-Based Heap Implementation We can represent a heap with n elements directly by means of an array of length N > n By-pass the binary tree ADT No explicit position ADT needed Idea similar to array-based implementation of binary trees The array cell at index 0 is unused The root of the heap is at index 1 The left child of the node at index i is at index 2i The right child of the node at index i is at index 2i + 1 The insertion operations corresponds to inserting at index n + 1 and thus runs in O(1) time Heaps and Priority Queues Page 13

14 Array-Based Heap: Example Last node Heaps and Priority Queues Page 14

15 Outline Heaps Heap-Sort Priority Queues Heaps and Priority Queues Page 1

16 Sorting with a Heap We can use a heap to sort a list of comparable elements Insert the elements one by one with a series of insertelement(e) operations Remove the elements in sorted order with a series of removemin() operations Running time analysis: Inserting the elements into the heap runs in O(n log n) time Removing the elements in sorted order from the heap runs in O(n log n) time In general (worst case), heap-sort runs in O(n log n) time For large n, heap-sort is much faster than quadratic sorting algorithms such as insertion-sort or selection-sort Heaps and Priority Queues Page 16

17 In-Place Heap-Sort We can implement Heap-Sort in-place for an array by using the front of the original array to implement the heap Step 1: Use the reverse comparator (e.g. instead of ) to build up the heap (by swapping elements) Step 2: Iteratively remove the maximum element from the heap and insert it in front of the list Phase 1: Phase 2: Heaps and Priority Queues Page 17

18 Outline Heaps Heap-Sort Priority Queues Heaps and Priority Queues Page 18

19 Priority Queue ADT A priority queue stores a collection of (key, element)-pairs, so-called items, and the keys are totally ordered Characteristic operations: insertitem(k,e): inserts an item with key k and element e removemin(): removes the item with the smallest key and returns its element minkey(): returns the smallest key of an item (no removal) minelement(): returns the element of an item with smallest key (no removal) General operations: size(): returns the number of items isempty(): indicates whether the priority queue is empty Two distinct items in a priority queue can have the same key Heaps and Priority Queues Page 19

20 List-Based Priority Queue There are two ways to implement a priority queue with a list Using an unsorted list insertitem(k,e) runs in O(1) time, since we can insert the item at the beginning of the list removemin(), minkey(), minelement() run in O(n) time since we have to traverse the entire list to find the smallest key Using a sorted list insertitem(k,e) runs in O(n) time, since we have to find the place where to insert the item removemin(), minkey(), minelement() run in O(1) time since the smallest key is at the beginning or end of the list Heaps and Priority Queues Page 20

21 UML Diagram Comparator islessthan(x,y) isequalto(x,y) etc. BasicCollection isempty() size() PriorityQueue insertitem(k,e) removemin() minkey() minelement() List etc. Position element() SortedPQ L: List C: Comparator UnsortedPQ L: List C: Comparator SinglyLinkedList first: ListNode n: Integer ListNode element: Object next: ListNode Heaps and Priority Queues Page 21

22 Heap-Based Priority Queues We can also use a heap to implement a priority queue Running times for different implementations Unsorted Sorted Operation List List Heap size, isempty minelement, minkey n 1 1 insertitem 1 n log n removemin n 1 log n In the long run, the heap-based implementation beats any list-based implementation Heaps and Priority Queues Page 22

23 UML Diagram List etc. Tree etc. BinaryTree etc. BasicCollection isempty() size() Heap insertkey(k) removemin() minkey() SortedList PriorityQueue L: List C: Comparator PriorityQueue insertitem(k,e) removemin() minkey() minelement() UnsortedList PriorityQueue L: List C: Comparator Comparator islessthan(x,y) isequalto(x,y) etc. BinaryTreeHeap T: BinaryTree C: Comparator ArrayHeap A: Array C: Comparator HeapPriorityQueue H: Heap C: Comparator Heaps and Priority Queues Page 23