CSCI 251 Ch. 8 Heaps and Treaps
When performing an insert, indicate each node's new location using the template tree's labels (n1...n7). Where will a new node P first be inserted?
n6 P > M, so descend to R. P < R, so insert P as R's left child.
The upward movement of a node in a max-heap
percolating
a queue where each item has a priority, and items with higher priority are closer to the front of the queue than items with lower priority.
priority queue
A ______ from a max-heap is always a removal of the root, and is done by replacing the root with the last level's last node, and swapping that node with its greatest child until no max-heap property violation occurs.
remove
Heap sort algorithm
see image
Implementing priority queues with heaps
see image
Percolate down algorithm
see image
Percolate up algorithm
see image
parent and child indices for a heap
see image
similar to a max-heap, but a node's key is less than or equal to its children's keys
min-heap
Node D was just inserted, and assigned a random priority of 47. Rotations are needed to not violate the heap property. Match the node value to the corresponding location in the tree template on the right after the rotations are completed.
n1 = d, 47 n2 = b, 12 n3 = g, 30 n4 = a, 5 n5 = h, 18
When performing an insert, indicate each node's new location using the template tree's labels (n1...n7). P is assigned a random priority of 65. To where does P percolate?
n3
When performing an insert, indicate each node's new location using the template tree's labels (n1...n7). Where will a new node H first be inserted?
n5
When performing an insert, indicate each node's new location using the template tree's labels (n1...n7). H is assigned a random priority of 20. To where does H percolate?
n5 The heap property is not violated. A rotation is not needed, so H stays at n5.
a complete binary tree that maintains the simple property that a node's key is greater than or equal to the node's childrens' keys.
max-heap
Which array could be heapified with the fewest number of operations, including all swaps used for percolating? (10, 20, 30, 40) (30, 20, 40, 10) (10, 10, 10, 10)
(10, 10, 10, 10) Heapifying this array doesn't require any swaps, since each node already satisfies the heap property.
Suppose the original array to be heapified is (11, 21, 12, 13, 19, 15). What is the heapified array? (11, 21, 12, 13, 19, 15) (21, 19, 15, 13, 12, 11) (21, 19, 15, 13, 11, 12)
(21, 19, 15, 13, 11, 12)
Each question starts from the original tree. Use this text notation for the tree: (J (F (C, G), Q (M, T))). A - means the child does not exist. What is the tree after removing G? (J (F (C, -), Q (M, T))) (J (C (-, F), Q (M, T)))
(J (F (C, -), Q (M, T)))
Each question starts from the original tree. Use this text notation for the tree: (J (F (C, G), Q (M, T))). A - means the child does not exist. What is the tree after removing Q? (J (F (C, G), M(-, T)) (J (F (C, G), T(M, -))
(J (F (C, G), M(-, T))
Assume servicePQueue is a priority queue with contents: 11, 22, 33, 44, 55. After calling Dequeue(servicePQueue) a total of 5 times, what will GetLength(servicePQueue) return? -1 0 Undefined
0 If all items have been removed, the priority queue's length is 0.
Assume servicePQueue is a priority queue with contents: 11, 22, 33, 44, 55. What does Dequeue(servicePQueue) return? 5 11 55
11
Suppose the original array to be heapified is (11, 21, 12, 13, 19, 15). What are the last 2 elements swapped? 11 and 19 11 and 21 19 and 21
11 and 19 Element 11 is less than both 13 and 19, and is swapped with the larger of the 2 children.
Suppose the original array to be heapified is (11, 21, 12, 13, 19, 15). What are the first 2 elements swapped? 11 and 21 21 and 13 12 and 15
12 and 15 The percolate down operation is performed first on node 12. 15 is greater than 12, and the 2 elements are swapped.
Suppose the original array to be heapified is (11, 21, 12, 13, 19, 15). The percolate down operation must be performed on which nodes? 15, 19, and 13 12, 21, and 11 All nodes in the heap
12, 21, and 11 The percolate down operation is performed on internal nodes only. Nodes 12, 21, and 11 are the heap's internal nodes.
What are the child indices for a node at index 6? 7 and 8 12 and 13 13 and 14 12 and 24
13 and 14
How many times will MaxHeapPercolateDown be called by Heapsort when sorting an array with 10 elements? 5 10 14 20
14 The first loop iterates for i = 4, 3, 2, 1, and 0, and the second loop iterates for i = 9, 8, 7, 6, 5, 4, 3, 2, and 1. MaxHeapPercolateDown is called once for each loop iteration, making 5 + 9, or 14, calls total.
Assume servicePQueue is a priority queue with contents: 11, 22, 33, 44, 55. After dequeuing an item, what will Peek(servicePQueue) return? 11 22 33
22 Peek returns the item at the queue's front, and 22 is now at the front.
Given a max-heap with levels 0, 1, 2, and 3, with the last level not full, after inserting a new node, what is the maximum possible swaps needed? 1 2 3
3 The node is inserted into level 3. If the node's key is the new maximum, swaps will occur with the parent in level 2, then level 1, and finally level 0 (the root).
For an array with 7 nodes, how many percolate-down operations are necessary to heapify the array?
3 The percolate down operation must be performed on nodes at indices 2, 1, and 0 to heapify the array.
Assume servicePQueue is a priority queue with contents: 11, 22, 33, 44, 55. What does GetLength(servicePQueue) return? 5 11 55
5
What is the parent index for a node at index 12? 3 4 5 6
5
For an array with 10 nodes, how many percolate-down operations are necessary to heapify the array?
5 The percolate down operation must be performed on nodes at indices 4, 3, 2, 1, and 0 to heapify the array.
Assume that lower numbers have higher priority and that a priority queue currently holds items: 54, 71, 86 (front is 54). The dequeue operation would return which item? 54 71 86
54 The dequeue operation returns the item at the front of the queue. 54 is at the front of the queue.
An _____ into a max-heap starts by inserting the node in the tree's last level, and then swapping the node with its parent until no max-heap property violation occurs.
insert
Assume that lower numbers have higher priority and that a priority queue currently holds items: 54, 71, 86 (front is 54). Where would an item with priority 60 reside after being enqueued? Before 54 After 54 After 86
After 54 Item 60 is lower priority than 54, but higher than 71, and will therefore reside between items 54 and 71 after being enqueued.
Assume that lower numbers have higher priority and that a priority queue currently holds items: 54, 71, 86 (front is 54). Where would an additional item with priority 54 reside after being enqueued? Before the first 54 After the first 54 After 86
After the first 54 Enqueued items are inserted after existing items of equal priority, so the second 54 will reside after the first.
Returns and removes the item at the front of PQueue
Dequeue(PQueue)
A priority queue implementation that requires objects to have a data member storing priority would implement the _____ function. Enqueue EnqueueWithPriority
Enqueue The Enqueue function doesn't require priority as an argument, since the priority is already within the enqueued object.
Inserts x after all equal or higher priority items
Enqueue(PQueue, x)
A priority queue implementation that does not require objects to have a data member storing priority would implement the _____ function. Enqueue EnqueueWithPriority
EnqueueWithPriority A priority still must be associated with each object in the priority queue. If the object doesn't have priority data, then the EnqueueWithPriority function would be implemented, and the priority would be passed as an argument.
Returns the number of items in PQueue
GetLength(PQueue)
Heap storage
Heaps are typically stored using arrays. Given a tree representation of a heap, the heap's array form is produced by traversing the tree's levels from left to right and top to bottom. The root node is always the entry at index 0 in the array, the root's left child is the entry at index 1, the root's right child is the entry at index 2, and so on.
Returns true if PQueue has no items
IsEmpty(PQueue)
(a) Treap Not a treap
Not a treap M's priority must be ≥ G's.
(d) Treap Not a treap
Not a treap Priorities obey heap property, but keys don't obey BST ordering property: H cannot be G's left child. Both properties must be obeyed in a treap.
Given a max-heap with N nodes, what is the worst-case complexity of an insert, assuming an insert is dominated by the swaps? O(N) O(logN)
O(logN) The height is O(logN), so the maximum number of swaps is O(logN).
Given a max-heap with N nodes, what is the complexity for removing the root? O(N) O(logN)
O(logN) The root is replaced by a last-level node, and then downward swaps may occur, limited by the height, which is O(logN).
Returns but does not remove the item at the front of PQueue
Peek(PQueue)
Heapify operation
The heapify operation starts on the internal node with the largest index and continues down to, and including, the root node at index 0. Given a binary tree with N nodes, the largest internal node index is ⌊N/2⌋ - 1.
(b) Treap Not a treap
Treap OK that F and H have same priority, as long as heap property is not violated.
(c) Treap Not a treap
Treap OK that G's priority is same as child F. G's must be greater than or equal .
The priority queue _____ operation removes and returns the item at the front of the queue, which has the highest priority.
dequeue
The priority queue _______ operation inserts an item such that the item is closer to the front than all items of lower priority, and closer to the end than all items of equal or higher priority.
enqueue
54 violates the max-heap property due to being greater than 44. True False
false 44 is not 54's parent, so no relation is required.
Suppose a treap is built by inserting nodes with main keys in this order: A, B, C, D, E, F, G. The treap will have 7 levels, with each level having one node with a right child. True False
false A BST would have such a structure. But upon each insert into a treap, the random priority may cause a rotate up, which forces some nodes to become left children. The tree is thus likely to be balanced.
If 2,000 customers are waiting for technical support, removing a customer from the min heap requires about 2,000 operations. True False
false A heap removal operation is worst-case O(logN). log_2(2000) is about 11, so only about 11 operations are required.
An array sorted in ascending order is already a valid max-heap. True False
false A max-heap can be used to sort an array, but a sorted array may not be valid max-heap. Ex: The array with values 10, 20, and 30 would have a root node with 2 larger children, and would not be a valid max-heap.
A treap's nodes have random main keys. True False
false A node being inserted already has a main key. The key is used to form a BST.
MaxHeapPercolateDown checks the node's left child first, and immediately swaps the nodes if the left child has a greater key. True False
false All children are checked before any child key is moved into the parent. If greater than the parent's key, the maximum child key is moved up into the parent.
The Dequeue and Peek operations both return the value in the root, and therefore have the same worst-case runtime complexity. True False
false Both functions return the value in the root, but the Dequeue function removes the value and the Peek function does not. Dequeue is worst-case O(logN) and Peek is worst-case O(1).
If items in a priority queue with a lower numerical value have higher priority, then a max-heap should be used to implement the priority queue. True False
false If the smallest numerical value is the highest priority, then the minimum value should be in the heap's root node. A min-heap has the minimum value in the root node.
Calling Heapsort on an array with 1 element will cause an out of bounds array access. True False
false In the first loop, i is initialized with -1 and the loop body is never executed. In the second loop, i is initialized with 0 and the loop body never executes.
A priority queue is always implemented using a heap. True False
false Many ways exist to implement a priority queue. Using a heap is common because priority queue operations have a simple mapping to equivalent heap operations that run efficiently.
33 violates the max-heap property due to being greater than 22. True False
false No relation between a node's two children is required.
The formula for computing a child index evaluates to -1 if the parent is a leaf node. True False
false The formula always computes non-negative child indices. If the parent is a leaf, the computed index will be outside of the heap array bounds.
The formula for computing child node indices does not work on the root node. True False
false The formulas 2 * i + 1 and 2 * i + 2 work correctly to compute child indices of 1 and 2 for the root node.
Heapsort uses recursion. True False
false The only function Heapsort calls is MaxHeapPercolateDown, which is not recursive. So, the Heapsort algorithm is not recursive.
Match each max-heap to the corresponding storage array. 57 42 19 13 6 7 15
heap a
Match each max-heap to the corresponding storage array. 57 19 42 13 6 7 15
heap b
Match each max-heap to the corresponding storage array. 57 42 15 6 19 7 13
heap c
Match each max-heap to the corresponding storage array. 57 19 42 6 7 13 15
heap d
operation used to turn an array into a heap
heapify
a sorting algorithm that takes advantage of a max-heap's properties by repeatedly removing the max and building a sorted array in reverse order.
heapsort
A ______ uses a main key that maintains a binary search tree ordering property, and a secondary key generated randomly (often called "priority") during insertions that maintains a heap property. The combination usually keeps the tree balanced.
treap
A customer with a higher priority has a lower numerical value in the min heap. True False
true
A max-heap's root always has the maximum key in the entire tree.
true
Heapsort's worst-case runtime is O(N log N). True False
true
60 violates the max-heap property due to being greater than 55. True False
true 55 is 60's parent, but 55 is not greater than or equal to 60, so a violation of the max-heap property has occurred.
When implementing a priority queue with a heap, no operation will have a runtime complexity worse than O(logN). True False
true Enqueue and dequeue operations have runtime O(logN). All other operations happen in constant time.
A max-heap's root must have the maximum key. True False
true If not, a violation of the max-heap property must exist somewhere along the path from the maximum-keyed node to the root.
MaxHeapPercolateDown has a precondition that nodeIndex is < arraySize. True False
true MaxHeapPercolateDown accesses the array at nodeIndex in the second statement, so the index must be less than the array size.
MaxHeapPercolateUp works for a node index of 0. True False
true Percolating up on the root is a valid call, although the algorithm will terminate immediately once the node index is checked in the first statement.
The formula for computing parent node index should not be used on the root node. True False
true Since the root node has no parent, the formula must not be used on the root node. The formula holds for all other nodes in the heap.
In MaxHeapPercolateUp, the while loop's condition nodeIndex > 0 guarantees that parentIndex is >= 0. True False
true The node index is an integer value, and the parent index is computed as ⌊(nodeIndex−1)/2⌋, implying that the parent index will always be >= 0.
A treap's nodes have random priorities. True False
true Upon an insert, the treap insert operation assigns the node with a random priority, then percolates the node up until the heap property is not violated.
Given N nodes, what is the height of a max-heap? ⌊logN⌋ N Depends on the keys
⌊logN⌋ The operations keep the tree height to the minimum: Each level is filled (left-to-right).