Heaps data ordered along paths from root to leaf
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Heaps
data ordered along paths from root to leaf
Heaps and applications
• what is a heap?
• how is a heap implemented?
• using a heap for a priority queue
• using a heap for sorting
Heap definitionComplete binary tree with data ordered so that data value in a node always precedes data in child nodes
30
2820
16
14 8
19
17 18
26
24 11
26
example:•integer values in descending order along path from root•blue node is only possible removal location•red node is only possible insertion location
Heap storageAn array is the ideal storage for a complete binary tree
30
2820
16
14 8
19
17 18
26
24
26
0
1
2
3
0
30 20 28 16 19 26 26 14 8 17 18 24/
0 1 2 3
a
size 12
level
Heap implementation
Assuming 0th element of array is unused,
• root node is at index 1
• for node at index i:
• parent node is at i/2
• child nodes are at 2i and 2i+1
• last node is at index size
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
30 20 28 16 19 26 26 14 8 17 18 24/
0 1 2 3
a
size 12
level
30
2820
16
14 8
19
17 18
26
24
26
0
1
2
3
implementation in an ADT:array and size
Comparable[] a;
int size;
private boolean full()
{ // first element of array is empty
return (size == a.length-1);
}
Heap operationsInsertion and deletion maintain the complete tree AND
maintain the array with no ‘holes’
30
2820
16
14 8
19
17 18
26
24
26
0
30 20 28 16 19 26 26 14 8 17 18 24 43a
size 12
43
Heap operations - terminologyheapify – reorganize data in an array so it is a heap
reheapify – reorganize data in a heap with one data item out of order
reheapify down – when data at root is out of order
reheapify up – when last data item is out of order
Heap operations - insertion
30
2820
16
14 8
19
17 18
26
24
26
0
30 20 28 16 19 26 26 14 8 17 18 24 29a
size 12
1. insert new data item after last current data
2. if necessary, ‘reheapify’ up
29
13
Heap operations - insertion
30
2820
16
14 8
19
17 18
26
24
26
0
30 20 28 16 19 26 26 14 8 17 18 24 29a
size 13
1. insert new data item after last current data
2. if necessary, ‘reheapify’ up
29
29
28
26
29 28 26
implementation in an ADT:insertion
public void add(Comparable data)
{
if (full()) // expand array
ensureCapacity(2*size);
size++;
a[size] = data;
if (size > 1)
heapifyUp();
}
implementation in an ADT:heapifyUp
private void heapifyUp(){ Comparable temp; int next = size; while (next != 1 && a[next].compareTo(a[next/2]) > 0) { temp = a[next]; a[next] = a[next/2]; a[next/2] = temp; next = next/2; }}
Heap operations - deletion
30
2820
16
14 8
19
17 18
26
24
26
0
30 20 28 16 19 26 26 14 8 17 18 24a
size 12
only the item at the root can be removed
1. delete the root data and replace with the last data item
2. if necessary, ‘reheapify’ down24
24
11
Heap operations - deletion
24
2820
16
14 8
19
17 18
26 26
0
24 20 28 16 19 26 26 14 8 17 18a
size 11
only the item at the root can be removed
1. delete the root data and replace with the last data item
2. if necessary, ‘reheapify’ down
28 26 24
28
26
24
implementation in an ADT:deletion
public Comparable removeMax(){ if (size == 0) throw new IllegalStateException(“empty heap”); Comparable max = a[1]; a[1] = a[size]; size--; if (size > 1) heapifyDown(1); return max;}
implementation in an ADT:heapifyDown
private void heapifyDown(int root){ Comparable temp; int next = root; while (next*2 <= size) // node has a child { int child = 2*next; // left child if (child < size && a[child].compareTo(a[child+1]) < 0) child++; // right child instead if (a[next].compareTo(a[child]) < 0) { temp = a[next]; a[next] = a[child]; a[child] = temp; next = child; } else; next = size; // stop loop }}
Heap operations – ‘heapify’make a heap from an unsorted array
buildHeap()
recursive construction of a heap: (post-order traversal)
1. heapify left subtree
2. heapify right subtree
3. send root to correct position using reheapifyDown()
1 2
3
implementation in an ADT:heapify an array - recursive
public void heapify ()
{
heapify(1);
}
private void heapify(int root)
{
if(root > size/2) return; //no children
heapify(root*2); // left subtree
if (root*2+1 <=size)
heapify(root*2+1); // right subtree
heapifyDown(root); // do root node
}
Heap operations – ‘heapify’iterative construction of a heap: (bottom-up) – O(n)
• the leaves are already (one node) heaps
• start at second row from bottom-heapifyDown()
• row by row to row 0 (root)leaves
implementation in an ADT:heapify an array - iterative
public void heapify ()
{
for (int next = size/2; next>=1; next--)
heapifyDown(next);
}
Heap application
these operations fit the requirements of the priority queue with O(log n) performance
priority queue implementation
insert (enqueue)
delete min (dequeue)
unsorted array O(1) O(n)
sorted array O(n) O(1)
unsorted linked list O(1) O(n)
sorted linked list O(n) O(1)
binary heap O(log n) O(log n)
21
Heap application - sorting
Heapsort
• in place sorting in O(n log n) time
• two stage procedure:
unsorted array -> heap -> sorted array
build heap
repeat [delete maximum ]
Heap application - sorting
m x
heap must be ordered opposite to final resulte.g., for ascending order sort, heap must be descending order
basic operation of second stage:
heap sorted
x m
x
x
m
m
1. remove max item in heap (m); last item gets moved to top2. last item gets heapified down3. put m in vacant space after heap
implementation in an ADT:heapsort
public void heapsort(){ heapify(); int keepSize = size; for (int next = 1; next <= keepSize; next++) { Comparable temp = removeMax(); a[size+1] = temp; } size = keepSize;}
Huffman coding with a heap
• Huffman codes are based on a binary tree– Left branch coded 0– Right branch coded 1– Coded characters are in leaves
Example Codesa 1b 010c 0001d 0000x 011y 001
a
0 1
0 1
0 1 0 1
0 1
d c
y b x
Building the tree1. Based on frequencies of characters
- Make heap (lowest first)
Example Frequenciesa 125b 15c 4d 3x 17y 12
125 a 15 b4 c3 d 17 x12 y
Building the tree
2. Remove two lowest from heap
- Make a tree with each as a subtree – add frequencies for root
- Put tree in heap by root frequency
125 a 15 b4 c3 d 17 x12 y
125 a15 b4 c 17 x12 y
15 b12 y 125 a17 x
3 d
4 c
125 a12 y 17 x15 b
4 c3 d
7
Building the tree
2. Remove two lowest from heap
- Make a tree with each as a subtree
- Put tree in heap by total frequency
3. Repeat until all in one tree . . .
125 a12 y 17 x15 b
4 c3 d
7
17 x
12 y
125 a15 b
4 c3 d
7
19
17 x
125 a
15 b12 y
4 c3 d
7
19 32
Building the tree
2. Remove two lowest from heap
- Make a tree with each as a subtree
- Put tree in heap by total frequency
3. Repeat until all in one tree . . .
17 x
125 a
15 b12 y
4 c3 d
7
19 32
17 x
125 a
15 b12 y
4 c3 d
7
19 32
51
Building the tree
2. Remove two lowest from heap
- Make a tree with each as a subtree
- Put tree in heap by total frequency
3. Repeat until all in one tree . . .
17 x
125 a
15 b12 y
4 c3 d
7
19 32
51
176
17 x
125 a
15 b12 y
4 c3 d
7
19 32
51
Translating the tree
4. Make table from tree
Example Codes
a 1
b 010
c 0001
d 0000
x 011
y 001
17 x
125 a
15 b12 y
4 c3 d
7
19 32
51
176
Using the Huffman coding
• To encode, use table:
day 00001001
• To decode, use tree
00001001 day
a 1b 010c 0001d 0000x 011y 001
a
0 1
0 1
0 1 0 1
0 1
d c
y b x
Related Documents
