Transcript Lecture 4 - Binary Heaps

The Binary Heap
Binary Heap
• Looks similar to a binary search tree
• BUT all the values stored in the subtree rooted at a node are
greater than or equal to the value stored at the node.
– In a min heap that is.
– We will mainly talk about min heaps, but it’s the same concept.
Binary Heap
• What are they used for?
– Priority Queue
– Performing Heapsort
Binary Heap
• Priority Queue
– A queue where you always extract the item with
the highest priority next.
– What operations do we need?
• An efficient deleteMin() and Insert()
• For our implementation we will achieve O(log n) time
for the deleteMin() and Insert() operations.
Binary Heap
• Balanced binary tree
– Can even store a binary heap in an array instead of
an actual binary tree.
– The children of node i are nodes 2i and 2i+1.
• Consider:
0
10
20
30
40
50
60
70
80
90
100
110
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
• Draw the tree
• What node is the parent of node i?
– Floor(i/2)
Binary Tree
0
10
20
30
40
50
60
70
80
90
100
110
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
10
20
30
40
80
50
90
100
60
110
120
70
130
Heap Operation : Insert
• Insert into the next open spot in the heap, or
the next array location.
– This will keep the heap balanced.
• However, in all likelihood this is not where the
element belongs
– Thus we have to do the Percolate Up procedure
– For example, if you inserted 25 into the next open
spot, it would be out of order.
Percolate Up
• If the parent of the new node is greater than the
inserted value, swap them.
– This is a single percolate up step.
• Continue this process until the inserted node’s
parent stores a number lower than it.
• Since the height of the tree is O(lg n), this is an
O(lg n) operation.
• What does this remind you of?
Insert
• Consider the tree we had before
– Insert 65
• Where do you insert it?
10
20
30
40
80
50
90
100
60
110
120
70
130
25
Now what?
Insert
• Consider the tree we had before
– Insert 65
• Where do you insert it?
10
20
30
40
80
50
90
100
60
110
120
70
130
25
Insert
• Consider the tree we had before
– Insert 65
• Where do you insert it?
10
20
30
40
80
50
90
100
25
60
110
120
130
70
Insert
• Consider the tree we had before
– Insert 65
• Where do you insert it?
10
25
20
40
80
50
90
100
60
110
120
30
130
70
Heap Operation: deleteMin
• First part is easy
– Just return the value stored in the root.
• Then what do we replace it with?
– Place the “last” node in the vacated root.
– Probably not the correct location.
– Percolate Down
Percolate Down
• Compare the element to its children.
– If one of the children is less than the node, swap
the lowest.
• This is a single percolate down step.
– CONTINUE until this “last” node has children with
larger values than it.
• Real life example
Heap Operation: Heapify
• Heapify or Bottom-Up Heap Construction
• How to construct a heap out of unsorted
elements.
1) Place all the unsorted elements in a complete
binary tree.
2) Going through the nodes in backwards order, and
skipping the leaf nodes, run Percolate Down on
each of these nodes.
•
•
Notice that each subtree below any node that has
already run Percolate Down is already a heap.
So after we run Percolate Down on the root, the whole
tree is a heap.
Heapify
• Let’s run Heapify on the following elements:
0
80
110
90
30
60
120
40
10
50
100
70
20
130
1
2
3
4
5
6
7
8
9
10
11
12
13
80
110
90
30
10
60
50
Where do we
start?
100
120
70
20
40
130
Heapify
• Let’s run Heapify on the following elements:
0
80
110
90
30
60
20
40
10
50
100
70
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
80
110
90
30
10
60
50
Where do we
look next?
100
40
20
70
120
130
Heapify
• Let’s run Heapify on the following elements:
0
80
110
90
30
60
20
40
10
50
100
70
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
80
110
90
30
10
60
50
Where do we
look next?
100
40
20
70
120
130
Heapify
• Let’s run Heapify on the following elements:
0
80
110
90
30
60
20
40
10
50
100
70
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
80
110
90
10
30
60
50
Where do we
look next?
100
40
20
70
120
130
Heapify
• Let’s run Heapify on the following elements:
0
80
110
90
30
60
20
40
10
50
100
70
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
80
110
20
10
30
60
50
100
90
70
120
40
130
Heapify
• Let’s run Heapify on the following elements:
0
80
110
90
30
60
20
40
10
50
100
70
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
80
110
20
10
30
60
50
Where do we
look next?
100
90
70
120
40
130
Heapify
• Let’s run Heapify on the following elements:
0
80
110
90
30
60
20
40
10
50
100
70
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
80
10
20
110
10
30
60
50
100
90
70
120
40
130
Heapify
• Let’s run Heapify on the following elements:
0
80
110
90
30
60
20
40
10
50
100
70
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
80
10
20
30
110
60
50
100
90
70
120
40
130
Heapify
• Let’s run Heapify on the following elements:
0
80
110
90
30
60
20
40
10
50
100
70
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
80
10
20
30
110
60
50
Where do we
look next?
100
90
70
120
40
130
Heapify
• Let’s run Heapify on the following elements:
0
80
110
90
30
60
20
40
10
50
100
70
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
10
80
20
30
110
60
50
100
90
70
120
40
130
Heapify
• Let’s run Heapify on the following elements:
0
80
110
90
30
60
20
40
10
50
100
70
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
10
30
20
80
110
60
50
100
90
70
120
40
130
Heapify
• Let’s run Heapify on the following elements:
0
80
110
90
30
60
20
40
10
50
100
70
120
130
1
2
3
4
5
6
7
8
9
10
11
12
13
10
30
20
50
110
60
80
100
90
70
120
40
130
Heapify
• Why can we NOT go through the nodes in forward order?
• What’s the running time of the algorithm to create a
heap?
– In a heap with n nodes, we run Percolate Down on n/2 of
those nodes.
– The max number of steps of any Percolate Down is?
O(log n)
– Thus an upper bound for Make-Heap is
O(n log n)
• We can do a more careful analysis for a tighter bound for
the running time.
Make-Heap Analysis
• On the board.
Heap Sort
• Now that we know the basic operations to perform on
a heap, we can use these to sort values using a heap.
• Basic Idea:
1) Insert all items into a heap
2) Extract the minimum items n times in a row storing the
values sequentially in an array.
•
What is the run time of Heap Sort?
–
–
•
Since each insert and extraction takes O(lg n) time.
This sort works in O(n lg n) time.
Let’s do an example.