Trees & Tree-Based Data Structures. Part 4: Heaps. Definition. Example. Properties. Example Min-Heap. Definition

Transcription

1 Trees & Tree-Based Data Structures Dr. Christopher M. Bourke Part 4: Heaps Definition Definition A (max) heap is a binary tree of depth d that satisfies the following properties. 1. It is full up to level d 1, every node at levels 0 through d 1 is present 2. At level d all nodes are full-to-the-left 3. Every node has a key value that is greater than both of its children First two conditions: fullness property Third condition: heap property Properties Min-Heap Heaps are not binary search trees 1 Keys are required to be unique, non-negative integers The maximum element is always at the top of the heap 5 30 The fullness property guarantees that d O(log n) Equivalent definition for min-heaps: both children are greater than the parent 92 63

2 Operations I Restricted Access Data Structure Operations II Restricted Access Data Structure Both operations will: Heaps are restricted access data structures; core operations: Get (and remove) maximum element ( getmax ) Insert element Preserve the heap properties Preserve the fullness property Guaranteed to be efficient O(d) = O(log n) Insert is not arbitrary Other general methods are not supported (arbitrary retrieve/remove) Insert Key Incorrect Operation I Insert a new key: Must preserve the fullness property and the heap property Heaps are not binary search trees We cannot treat them the same Incorrect Operation II Incorrect Operation III 15 21

3 Incorrect Operation IV Incorrect Operation V Insert Key Insert First Step Solution: preserve the fullness property first Insert at the next available spot: At the deepest level At the left-most available spot Start a new level if necessary Insert Key Insert I Fullness property is preserved Heap property may not be satisfied Fix the heap ( heapify ): exchange key values up the tree until the heap property is satisfied or we reach the root

4 Insert II Insert III swap Insert IV Insert V swap Insert VI Insert VII

5 Insert VIII Insert IX swap Insertion Analysis Input 1 curr u : A heap H and an inserted node u 2 while curr H.root and curr.key > curr.parent.key do 3 swap curr.key, curr.parent.key 4 curr curr.parent Assume that we can find the next available spot for free Insertion: O(1) : O(d) comparisons and swaps in the worst case Fullness property guarantees O(log n) Incorrect Operation: Heap property ensures that the maximum value is at the root Variation: peek Get max generally removes (and returns) the root element Same problem as before: we need to fix the heap and satisfy both heap property and fullness property

6 Incorrect Operation: Incorrect Operation: Incorrect Operation: Incorrect Operation: Incorrect Operation: Remove (and save) the root element. Preserve the fullness property first Replace the root with the last element Then heapify downward

7 swap

8 swap Algorithm Again: assume free access to the last element Swap last and root From the root, swap the larger of the two children Repeat until both children are less or we ve reached a leaf Pseudocode: exercise Implementations Array-Based Implementation Leverage other data structures and composition Array-based implementation Tree-based implementation Since the tree is full, data can be stored contiguously Suggests that an array can be used to store nodes (or node references) Store root at index 1 If a node u is stored at index i: Left child: 2i Right child: 2i + 1 Parent: i 2 May use zero-indexing by subtracting 1.

9 Array-Based Implementation Relations Array-Based Implementation i 2 p i u 2i l r 2i i 2 p i u 2i l 2i + 1 r Array-Based Implementation Advantages Tree-Based Implementation Familiar underlying data structure (arrays or array-based list) Cannot (in general) use linked lists: no random access, no constant-time jumping to left/right/parent Simple, easy way to traverse the tree Fullness property guarantees data contiguity (in general, binary trees should not be implemented with arrays) Get free (constant-time) access to: Last element: at index n Next available spot: at index n + 1 Be sure to keep track of the size of the heap! Possible to implement using a tree data structure (node with left/right/parent references) Fundamental difference: we cannot jump to the last node or the next available spot Still possible to access these in O(d) = O(log n) time Tree-Based Implementation Finding the next available spot: outline Tree-Based Implementation Finding the next available spot: outline r Given n: number of nodes in the heap Compute the depth: d = log 2 (n) Start at root r Question: is the available spot in r s left or right subtree? L R level d level d at most 2d 2 at most 2d 2 d 1 2 k = 2 d 1 k=0 Number of nodes at level d is m = n (2 d 1) If m < 2d 2, the open If m 2d 2, the open slot is in the left slot is in the right subtree subtree

10 Tree-Based Implementation Finding the next available spot: outline Array-Based Implementation Java Tutorial Repeat analysis until you reach a single node tree with either its left or right child open Constant number of computations at each level O(d) = O(log n) Doesn t ruin overall running time More complex, more operations than an array-based implementation Design and implement a max-heap data structure (for Integer s) Use an ArrayList to simplify Support both insert and getmax operations Applications Priority Queue Heaps are used as fundamental data structures in many algorithms Two immediate applications: Efficient Priority Queue implementation Sorting Elements are inserted (arbitrarily) But: elements are dequeued according to highest priority (not FIFO) Heap provides both operations in an efficient manner, O(log n) Heap property based on element s priority Heap Sort Heap Sort Given n elements Insert each one into a min/max heap Remove each one until the heap is empty Removed order gives a sorted collection! Analysis: each insert/remove is at most O(log n) n iterations of each insert/remove; overall Smart Data Structures and dumb code are a lot better than the other way around. Eric S. Raymond O(n log n) Java implementation