Heapsort
Lecture 4
Asst. Prof. Dr. İlker Kocabaş
Sorting Algorithms
• Insertion sort
• Merge sort
• Quicksort
• Heapsort
• Counting sort
• Radix sort
• Bucket sort
• Order statistics
Heapsort
• The binary heap data structure is an array object that can
be viewed as a complete binary tree. Each node of the
tree corresponds to an element of the array that stores the
value in the node.
• An array A[1 ... n] that represents a heap is an object with
two attributes:
length[A] : The number of elements in the array
heap-size[A] : The number of elements in the heap
stored within the array A
heap-size[A]≤ length[A].
Heaps
• The root of the tree is A[1].
• Given the index i of a node, the indices of its
parent and children can be computed as
PARENT(i)
return i / 2 
LEFT(i)
return 2i
RIGHT(i)
return 2i+1
Heap property
• Two kinds of heap: Maximum heap and minimum
heap.
•Max-heap property is that for every node i other
than the root
A[ PARENT (i)]  A[i]
•Min-heap property is that for every node i other
than the root
A[ PARENT (i)]  A[i]
Heap property
In both kinds, the values in the nodes satisfy the
corresponding property (max-heap and min-heap
properties)
Heap property
1
16
3
2
10
14
4
5
8
7
8
9
10
3
4
1
6
7
9
11
4
A max-heap viewed as a binary tree
5
Heap property
•
•
•
•
We need to be precise in specifying whether we need
a max-heap or a min-heap.
–
For example min-heaps are commonly used in priority queues.
We define the height of a node in a heap to be the
number of edges on the longest simple downward path
from the node to a leaf.
We define the height of the heap to be the height of its
root.
The height of a heap is Ω(lg n).
Heap property
In this chapter we will consider the following basic procedures:
• The MAX-HEAPIFY which runs in O(lg n), is the key to
maintaining the max-heap.
• The BUILD-MAX-HEAP which runs in O(n), produces a max
heap from unordered input array.
• The HEAP-SORT which runs in O(nlg n), sorts an array in place.
• Procedures which allow the heap data structure to be used as
priority queue.
o MAX-HEAP-INSERT
o HEAP-EXTRACT-MAX
o HEAP-INCREASE-KEY
o HEAP-MAXIMUM
Maintaining the heap property
MAX-HEAPIFY is an important subroutine for manipulating max-heaps.
When MAX-HEAPIFY(A,i) is called it forces the value A[i] “float down”
in the max heap so that the the subtree rooted at index i becomes a
max heap.
Maintaining the heap property
MAX  HEAPIFY ( A, i )
1
l  LEFT( i )
2
r  RIGHT( i )
3
if l  heap _ size[ A] and A[l ]  A[i ]
4
then largest  l
5
else largest  i
6
7
8
9
10
if r  heap _ size[ A] and A[ r ]  A[largest ]
then largest  r
if largest  i
then exchange A[i ]  A[largest ]
MAX  HEAPIFY ( A, larges t )
The action of MAX-HEAPY(A, 2)
with heap-size[A]=10
The Running Time of MAX-HEAPIFY
The running time of MAX-HEAPIFY
• Fix up the relationships among the parent and children
(1)
• Calling for MAX-HEAPIFY : The children’s subtrees
each have size at most 2n/3 (The worst case occurs
when the last row of the tree is exactly half full)
T (n)  T (2n / 3)  (1)
T (n)  O(lg n) (by case 2 of master theorem)
Building a heap
We note that the elements in the subarray
A[( n/ 2  1),, n]
are all leaves of the tree. Therefore the procedure
BUILD-MAX-HEAP goes through the remaining
nodes of the tree and runs MAX-HEAPIFY on
each one
Building a heap
BUILD_MAX_ HEAP ( A )
1
2
3
heap _ size [ A ]  length[ A ]
for i  length[ A] / 2 downto 1
do MAX_HEAPIF Y( A,i )
Building a
Heap(contnd.)
Buiding a Heap (contd.)
Running time:
• Each call to MAX-HEAPIFY costs O(lg n) time,
• There are O(n) such calls.
• The running time is
T (n)  O(n lg n)
(not asymptotically tight.)
Buiding a Heap (contd.)
Asymptotically tight bound:
We note that heights of most nodes are small.
An n-element heap has height lg n
At most n/2h+1 nodes of any height h.
Buiding a Heap (contd.)
1
Maximum number of nodes
at height h (n=11)
16
3
2
10
14
4
5
8
7
8
9
10
3
4
1
h
6
7
9
11
4
5
max # nodes

 n / 2 h1

Actual # nodes
0
6
6
1
3
2
2
2
2
3
1
1
Buiding a Heap (contd.)
Asymptotically tight bound (cont.)
Time required by MAX_HEAPIFY
when called on a node of height h is O(h)
Buiding a Heap (contd.)
T ( n) 
lg n   n 

h0
lg n  h
 2 h 1  O(h)  O(n  2 h )
h 0
x n 1  1
x 
1 x
k 0
n

k
 kx 
x
k
k 0
(1  x)
2
(for | x | 1 )
For x  1 / 2 we have


1/ 2
k 0
(1  1 / 2) 2
k
 k x   k (1 / 2) 
k 0
k
Buiding a Heap (contd.)
Thus, the running time of BUILD - MAX - HEAP
can be bounded as
lg n  h
T ( n)  O ( n 
h 0
2

)  O(n 
h
h 0
h
2
h
)  O ( n)
The heapsort algorithm
HEAPSORT ( A)
1
BUILD - MAX - HEAP(A)
2
for i  length[ A] downto 2
3
do exchange A[1]  A[i ]
4
heap  size[ A]  heap  size[ A] - 1
5
MAX - HEAPIFY( A,1)
The heapsort
algorithm
Priority queues
• Heapsort is an excellent algorithm, but a good
implementation of quicksort usually beats it in
practice.
• The heap data structure itself has an enormous
utility.
• One of the most popular applications of heap: its
use as an efficient priority queue.
Priority queues(contd.)
• A priority queue is a data structure for maintaining a set S of
elements, each with an associated value called a key.
• A max-priority queue suppports the following operations:
INSERT(S,x) inserts the element x into the set S.
MAXIMUM(S) returns the element of S with the largest key.
EXTRACT-MAX(S) removes and returns the element of S with the
largest key
INCREASE-KEY(S,x,k) increases the value of element x’s key to
the new value k, which is assumed to be k ≥ x.
The MAXIMUM operation
The procedure HEAP-MAXIMUM implements the
MAXIMUM operation
HEAP-MAXIMUM(A)
1 return A[1]
T(n)=Θ(1)
The EXTRACT-MAX operation
HEAP-EXTRACT-MAX removes and returns the element of the
array A with the largest key
HEAP-EXTRACT-MAX(A)
1 if heap-size[A]<1
2
then error “heap underflow”
3 max←A[1]
4 A[1]←A[ heap-size[ A]]
5 heap-size[ A]←heap-size[ A]-1
6 MAX-HEAPIFY(A,1)
7 return max
T (n)  O(lg n)
The INCREASE-KEY operation
HEAP-INCREASE-KEY increases the value of element x’s key
to the new value k which is greater than or equal to x.
HEAP-INCREASE-KEY(A, i, key)
1 if key < A[i]
2
then error “new key is smaller than current key”
3 A[i]←key
4 while i >1 and A[ PARENT(i)] < A[i]
5
do exchange A[i] ↔ A[ PARENT(i)]
6
i ← PARENT(i)
T (n)  O(lg n)
The operation of HEAP-INCREASE-KEY
Increasing the
key=4 to15
The INSERT Operation
The MAX-HEAP-INSERT implements the insert operation.
MAX-HEAP-INSERT(A, key)
1 heap-size[A]← heap-size[A]+1
2 A[ heap-size[ A]] ← - 
3 HEAP-INCREASE-KEY(A, heap-size[A], key)
T (n)  O(lg n)