View
6
Download
0
Category
Preview:
Citation preview
CIS210 1
Topic
Binary Heaps
CIS210 2
Binary Heaps
as Non-linear Data Structures
CIS210 3
A Binary Heap?
A binary tree that satisfies two conditions:
The shape condition
The (partial) order condition between every
node and the nodes in its left and right
subtrees.
Heap order property
CIS210 4
A Binary Heap
TrightTleft
root
+ +Heap
Order
Condition Shape
Condition
CIS210 5
1. The Shape Condition of Heaps
The binary tree must be a complete binary
tree.
CIS210 6
2. The Order Condition of Heaps
There is a necessary ordering relationship
between a node and its children.
Each node in a tree has a key which is more
extreme (greater or less) than or equal to the
key of its parent.
Note:
There is no necessary ordering relationship
between a node and its siblings!
CIS210 7
The Order Condition of Heaps
For every node in the binary tree, the value
stored in that node must be greater than or
equal to the value in each of its children.
A max-heap
For every node in the binary tree, the value
stored in that node must be less than or equal
to the value in each of its children.
A min-heap
CIS210 8
A Binary Max-Heap?
A special complete binary tree s.t.
The search key contained in any node is greater
(larger) than or equal to the search key in each of its
children.
The search key contained in any node is never less
(smaller) than the search key in each of its children.
Every level except the deepest must contain as many
nodes as possible, and at the deepest level, all the
nodes are as far left as possible.
The root node has the largest key!
CIS210 9
Logical Structure of Binary Max-Heaps
TrightTleft
root
CIS210 10
Example: Binary Max Heap?
10
9 6
3 2 5
10
9 6
3
10
9
CIS210 11
A Binary Min-Heap?
A special complete binary tree s.t.
The search key contained in any node is less (smaller)
than or equal to the search key in each of its children.
The search key contained in any node is never greater
(larger) than the search key in each of its children.
Every level except the deepest must contain as many
nodes as possible, and at the deepest level, all the
nodes are as far left as possible.
The root node has the smallest key!
CIS210 12
Logical Structure of Binary Min-Heaps
TrightTleft
root
CIS210 13
Example:
2
3 6
10 5 9
2
3 6
10
2
3
CIS210 14
The World of Binary Heaps
Binary Trees
Complete
Binary Trees
(Binary)
HeapsHeap-order
Property
Shape PropertyMin-Heaps
Max-Heaps
CIS210 15
How to Represent a Binary Heap?
A heap is a complete binary tree!
An efficient array-based representation
Represent a node in the complete binary tree
as
A data
Represent the complete binary tree as an array.
CIS210 16
An Array-Based Representation of a Binary Heap
0
1
2
3
4
5
.
.
.
Data
10
9
6
3
2
5
Root
Heap[0]
Heap
10
9 6
3 2 5
CIS210 17
An Array-Based Representation of a Binary Heap
const int MAX_NODES = 100;
typedef string DataType;
DataType Heap[MAX_NODES];
int Root;
CIS210 18
Finding Parent and Children in a Binary Heap
For any node Heap[ i ]
Its left child =
Heap [ 2 * i + 1 ]
Its right child =
Heap [ 2 * i + 2 ]
Its parent =
Heap [ (i -1) / 2 ]
CIS210 19
Operations on Binary Max-heaps
Create an empty heap.
Destroy a heap.
Insert (add) a new item to the heap.
Retrieve and then delete a heap’s root item.
(This item has the largest search key.)
Determine whether a heap empty?
...
CIS210 20
Insert an Item Into a Binary Max-heap
9
5 6
3 2
9
5 6
3 2 15
Insert 15
Heap:
CIS210 21
Example: Insert 15
9
5 15
3 2 6
9
5 6
3 2 15
15
5 9
3 2 6
Heapify-Up Heapify-Up
CIS210 22
Heapify-Up
Heapify-Up (Heap, root, bottom):
The heap order may be violated only at the
bottom node.
Restores the heap order between the root and
the bottom.
CIS210 23
Heapify-Up
Heapify-Up (Heap, root, bottom):
If bottom > root then
Set Parent to the index of bottom node;
If heap[Parent] < heap[bottom] then
• Swap heap[Parent] with heap[bottom];
• Heapify-Up (Heap, root, Parent);
CIS210 24
Insert an Item Into a Binary Max-heap
Insert (Heap, item):
Increment the size of the heap;
Put item in the next available position;
Heapify-Up (Heap, 0, size-1);
CIS210 25
Example: Insert 15
9
5 6
3 2
9
5 6
3 2 150
1
2
3
4
5
.
.
.
95632
0
1
2
3
4
5
.
.
.
9563215
CIS210 26
Example: Insert 15
9
5 15
3 2 6
9
5 6
3 2 15
15
5 9
3 2 6
0
1
2
3
4
5
.
.
.
9563215
0
1
2
3
4
5
.
.
.
9515326
0
1
2
3
4
5
.
.
.
1559326
Heapify-Up Heapify-Up
CIS210 27
Retrieve & Delete a heap’s root item
10
9 6
3 2 5
9 6
3 2 5
Delete the root
CIS210 28
Example: Delete the root
9 6
3 2 5
5
9 6
3 2 5
9
5 6
3 2
Heapify-Down
CIS210 29
Heapify-Down
Heapify-Down (Heap, root, bottom):
The heap order may be violated only at the
root node.
Restores the heap order between the root and
the bottom.
CIS210 30
Heapify-Down
Heapify-Down (Heap, root, bottom):
If root is not a leaf then
Set BiggerChild to the index of child with
larger value.
If heap[root] < heap[BiggerChild] then
• Swap heap[root] with heap[BiggerChild];
• Heapify-Down (BiggerChild, bottom);
CIS210 31
Retrieve & Delete a heap’s root item
DeleteTheRoot (Heap):
Delete the root value;
Move the last leaf value into the root position;
Decrement the size of the heap;
Heapify-Down (Heap, 0, size-1);
CIS210 32
Example: Delete the root
0
1
2
3
4
5
.
.
.
96325
10
9 6
3 2 5
9 6
3 2 50
1
2
3
4
5
.
.
.
1096325
CIS210 33
Example: Delete the root
0
1
2
3
4
5
.
.
.
95632
9 6
3 2 5
5
9 6
3 2 5
9
5 6
3 2
0
1
2
3
4
5
.
.
.
96325
0
1
2
3
4
5
.
.
.
596325
Heapify-Down
CIS210 34
Heap ADT
//--------------------------------------------------------------------
// heap.h
// Class declaration for the array implementation of the Heap ADT
//--------------------------------------------------------------------
using namespace std;
const int defMaxHeapSize = 10; // Default maximum heap size
CIS210 35
Heap ADT
template < class DT >
class Heap
{
public:
// Constructor
Heap ( int maxNumber = defMaxHeapSize );
// Destructor
~Heap ();
CIS210 36
Heap ADT
// Heap manipulation operations
void insert ( const DT &newElement ); // Insert element
DT removeMax (); // Remove max pty element
void clear (); // Clear heap
// Heap status operations
bool isEmpty () const; // Heap is empty
bool isFull () const; // Heap is full
CIS210 37
Heap ADT
// Output the heap structure -- used in testing/debugging
void showStructure () const;
void writeLevels () const; // Output in level order
CIS210 38
Heap ADT
private:
// Data members
int maxSize, // Maximum number of elements in the heap
size; // Actual number of elements in the heap
DT *dataItems; // Array containing the heap elements
};
CIS210 39
Binary Heap Operations -Analysis
The height of a complete binary tree with N nodes is
O(log N)
Worst-case running time:
Heapify-Up
O(log N)
Insert
O(log N)
Heapify-Down
O(log N)
DeletetheRoot
O(log N)
CIS210 40
Transform an Array To a
Binary (Max- or Min-) Heap
CIS210 41
Build a Binary Max-Heap
Convert an array into a max-heap.
6 3 5 9 2 10
0 1 2 3 4 5
10 9 6 3 2 5
0 1 2 3 4 5
Build a max-heap
10 6 9 3 2 5
0 1 2 3 4 5
CIS210 42
Building a Binary Max-Heap -Approach 1
Approach 1:
N inserts (Heapify-Up)
Top-down heap building
CIS210 43
Example: Transform an Array into a Binary Max-Heap -
Approach 1
6 3 5 9 2 10
0 1 2 3 4 5
10 6 9 3 2 5
0 1 2 3 4 5
?
CIS210 44
Example: Approach 1
6 3 5 9 2 10
0 1 2 3 4 5
6 3 5 9 2 10
0 1 2 3 4 5
6
Insert
Insert
CIS210 45
Example: Approach 1
6 3 5 9 2 10
0 1 2 3 4 5
6 3 5 9 2 10
0 1 2 3 4 5
6
3 5
Insert
6
3
Insert
CIS210 46
Example: Approach 1
9
6 5
3
9 6 5 3 2 10
0 1 2 3 4 5
Insert
2
9
6 5
3
9 6 5 3 2 10
0 1 2 3 4 5
Insert
CIS210 47
Example: Approach 1
10
6 9
3 2 5
10 6 9 3 2 5
0 1 2 3 4 5
CIS210 48
Quiz: Top-down Construction of a Binary Min-Heap?
6 3 5 9 2 10
0 1 2 3 4 5
2 3 5 9 6 10
0 1 2 3 4 5
?
CIS210 49
Building a Binary Heap-Approach 2
Approach 2:
Using Heapify-Down
Bottom-up heap building
CIS210 50
Example: Transform an Array into a Binary Max-Heap -
Approach 2
6 3 5 9 2 10
0 1 2 3 4 5
10 9 6 3 2 5
0 1 2 3 4 5
?
CIS210 51
Example: Transform an Array into a Binary Max-Heap -
Approach 2
6 3 5 9 2 10
0 1 2 3 4 5
6 3 5 9 2 10
0 1 2 3 4 5
6
3 5
9 2 10
6
3 5
9 2 10
Heapify-Down
CIS210 52
Example: Approach 2
6 3 5 9 2 10
0 1 2 3 4 5
6 3 5 9 2 10
0 1 2 3 4 5
6
3 5
9 2 10
6
3 5
9 2 10
Heapify-Down
CIS210 53
Example: Approach 2
6 3 5 9 2 10
0 1 2 3 4 5
6 3 5 9 2 10
0 1 2 3 4 5
6
3 5
9 2 10
6
3 5
9 2 10
Heapify-Down
CIS210 54
Example: Approach 2
6 3 5 9 2 10
0 1 2 3 4 5
6 3 10 9 2 5
0 1 2 3 4 5
6
3 5
9 2 10
6
3 10
9 2 5
Heapify-Down
CIS210 55
Example: Approach 2
6 3 10 9 2 5
0 1 2 3 4 5
6 9 10 3 2 5
0 1 2 3 4 5
6
3 10
9 2 5
6
9 10
3 2 5
Heapify-Down
CIS210 56
Example: Approach 2
6 9 10 3 2 5
0 1 2 3 4 5
10 9 6 3 2 5
0 1 2 3 4 5
6
9 10
9 2 5
10
9 6
3 2 5
Heap!
Heapify-Down
CIS210 57
Quiz: Bottom-up Construction of a Binary Min-Heap?
6 3 5 9 2 10
0 1 2 3 4 5
2 3 5 9 6 10
0 1 2 3 4 5
?
CIS210 58
Build a Binary Heap - Analysis
Top-down Approach 1:
N inserts (Heapify-Up)
Worst-case running time
O(N log N)
CIS210 59
Build a Binary Heap - Analysis
Bottom-up Approach 2:
N Heapify-Down
Worst-case running time
O(N log N)
O(N) linear time!
CIS210 60
Applications of
Heaps
CIS210 61
Applications of Heaps
Priority queues
Sorting
CIS210 62
A Better Data Structure for PQ?
Worst-case time complexity of a heap-based
implementation of PQ:
Enqueue
O(log N)
Dequeue
O(log N)
CIS210 63
What is Heap Sort?
A sorting algorithm using an advanced data
structure called a heap!
CIS210 64
Heap Sort
Convert an array of unsorted data into a max-heap.
Take the root element from the heap and put it into its place.
Re-heap the remaining elements
via the reheapfication downward, i.e. Heapify-Down!
Repeat until all elements are in the correct positions.
CIS210 65
Heap Sort
Sorted
In an ascending orderHeapify-Down
A diminishing heap & A growing sorted array
An unsorted array
A Max-Heap
CIS210 66
Example: Heap Sort
6 3 5 9 2 10
0 1 2 3 4 5
2 3 5 6 9 10
0 1 2 3 4 5
Sorting?
CIS210 67
Example: Transform an Array into a Heap
6 9 10 3 2 5
0 1 2 3 4 5
10 9 6 3 2 5
0 1 2 3 4 5
6
9 10
9 2 5
10
9 6
3 2 5
Max-Heap
CIS210 68
Example: Heap Sort
10 9 6 3 2 5
5 9 6 3 2 10
9 5 6 3 2 10
Max-Heap
CIS210 69
Example: Heap Sort
9 5 6 3 2 10
2 5 6 3 9 10
6 5 2 3 9 10
CIS210 70
Example: Heap Sort
6 5 2 3 9 10
3 5 2 6 9 10
5 3 2 6 9 10
CIS210 71
Example: Heap Sort
5 3 2 6 9 10
2 3 5 6 9 10
3 2 5 6 9 10
CIS210 72
Example: Heap Sort
3 2 5 6 9 10
2 3 5 6 9 10
2 3 5 6 9 10
CIS210 73
Example: Heap Sort
2 3 5 6 9 10
2 3 5 6 9 10
Sorted!
CIS210 74
Quiz: Heap Sort?
6 3 5 9 2 10
0 1 2 3 4 5
10 9 6 5 3 2
0 1 2 3 4 5
Sorting?
CIS210 75
Heap Sort
template < class DT >
void heapSort ( DT dataItems [], int size )
// Heap sort routine. Sorts the data items in the array in ascending
// order based on priority.
{
DT temp; // Temporary storage
int j; // Loop counter
// Build successively larger heaps within the array until the
// entire array is a heap.
for ( j = (size-1)/2 ; j >= 0 ; j-- )
moveDown(dataItems,j,size);
CIS210 76
Heap Sort
// Swap the root data item from each successively smaller heap with
// the last unsorted data item in the array. Restore the heap after
// each exchange.
for ( j = size-1 ; j > 0 ; j-- )
{
temp = dataItems[j];
dataItems[j] = dataItems[0];
dataItems[0] = temp;
moveDown(dataItems,0,j);
}
}
CIS210 77
Heap Sort
template < class DT >
void moveDown ( DT dataItems [], int root, int size )
// Restores the binary tree that is rooted at root to a heap by moving
// dataItems[root] downward until the tree satisfies the heap property.
// Parameter size is the number of data items in the array.
{
DT insertDataItem; // Data item to be inserted -- dataItems[root]
int stop, // (Re)insertion point found
j; // Array index that moves down the heap
insertDataItem = dataItems[root];
stop = 0;
j = 2*root+1;
while ( j < size && !stop )
{
if ( j < size-1 &&
dataItems[j].pty() < dataItems[j+1].pty() )
j++;
if ( insertDataItem.pty() >= dataItems[j].pty() )
stop = 1;
else
{
dataItems[(j-1)/2] = dataItems[j];
j = 2*j+1;
}
}
dataItems[(j-1)/2] = insertDataItem;
}
CIS210 78
Heap Sort - Analysis
The worst-case running time
O(n log n)
The best-case running time
O(n log n)
The average-case running time
O(n log n)
Recommended