HEAPSORT

WHY STUDY HEAPSORT?

 It is a well-known, traditional sorting algorithm you will

be expected to know

 Heapsort is always O(n log n)

 Quicksort is usually O(n log n) but in the worst case
slows to O(n2)
 Quicksort is generally faster, but Heapsort is better in
time-critical applications.
 IDEA
 Store N elements in a binary heap tree.

 Perform delete_Max (delete largest element)

operation N times, storing each element deleted from
the heap into another array.
 Copy back the array.

• Not very efficient to use two arrays.

• Improvement – use single array for the binary
heap and the sorted elements
WHAT IS A “HEAP”?

 A heap is a Balanced left-filled binary tree T that

stores a key-element pairs at its internal nodes.

 It satisfies following properties:

• MinHeap: key(parent)  key(child)

OR
• MaxHeap: key(parent) ≥ key(child)
HEAPS

Max Heap Min Heap

BALANCED BINARY TREES

 Recall:
 The depth of a node is its distance from the root.
 The depth of a tree is the depth of the deepest node.
 A binary tree of depth n is balanced if all the nodes at
depths 0 through n-2 have two children.

n-2
n-1
n
Balanced Balanced Not balanced
LEFT-JUSTIFIED BINARY TREES

 A balanced binary tree is left-justified if:

 all the leaves are at the same depth, or
 all the leaves at depth n+1 are to the left of all the nodes
at depth n.

Left-justified Not left-justified

PLAN

1. First, we will learn how to turn a Balanced Left Justified

Binary tree into a heap.

2. Next, we will learn how to turn a binary tree back into a heap
after it has been changed in a certain way.

3. Finally we will see how to use these ideas to sort an array.

CONSTRUCT A
MAXHEAP:HEAPIFY
 Given a node that does not have the heap property, you can
give it the heap property by exchanging its value with the
value of the larger child

12 14

8 14 8 12
Blue node does not Blue node has
have heap property heap property

 This is sometimes called Heapify

 Notice that the child may have lost the heap property
STEP 1 : CONSTRUCTING A HEAP

 A tree consisting of a single node is automatically a heap.

 We construct a heap by adding nodes one at a time:
 Add the node just to the right of the rightmost node in
the deepest level.
 If the deepest level is full, start a new level.
 Examples:

Add a new Add a new

node here node here
CONSTRUCTING A HEAP II

 Each time we add a node, we may destroy the heap

property of its parent node.
 To fix this, we heapify.

 But each time we heapify, the value of the topmost node

in the sift may increase, and this may destroy the heap
property of its parent node.
 We repeat the heapify process, moving up in the tree,
until either
 We reach nodes whose values don’t need to be
swapped (because the parent is still larger than both
children), or
 We reach the root.
CONSTRUCTING A HEAP III
8 8 10 10

10 8 8 5

1 2 3

10 10 12

8 5 12 5 10 5

12 8 8
OTHER CHILDREN ARE NOT AFFECTED
12 12 14

10 5 14 5 12 5

8 14 8 10 8 10

 The node containing 8 is not affected because its parent gets larger, not
smaller.
 The node containing 5 is not affected because its parent gets larger, not
smaller.
 The node containing 8 is still not affected because, although its parent got
smaller, its parent is still greater than it was originally.
A SAMPLE HEAP
 Here’s a sample binary tree after it has been heapified
25

22 17

19 22 14 15

18 14 21 3 9 11

 Notice that heapified does not mean sorted

 Heapifying does not change the shape of the binary tree;
this binary tree is balanced and left-justified because it
started out that way
 STEP II: GET SORTED ARRAY

•As largest element is at the root of tree.

•Remove the root element and make right most node at

deepest level root node .

•By doing so, tree may not be HEAP tree.

•So, make it heap again (heapify).

 REMOVING THE ROOT
 Notice that the largest number is now in the root
 Suppose we discard the root:
11
25

22 17 22 17

19 22 14 15
19 22 14 15
18 14 21 3 9 11
18 14 21 3 9

Remove the rightmost leaf at the deepest level and use

it for the new root
THE HEAPIFY METHOD I
 Our tree is balanced and left-justified, but no longer a heap
 However, only the root lacks the heap property

11

22 17

19 22 14 15

18 14 21 3 9

 We can heapify the root.

 After doing this, one and only one of its children may have
lost the heap property.
THE HEAPIFY METHOD II
 Now the left child of the root (still the number 11) lacks the
heap property.
22

11 17

19 22 14 15

18 14 21 3 9

 We can heapify() this node.

 After doing this, one and only one of its children may have
lost the heap property.
THE HEAPIFY METHOD III
 Now the right child of the left child of the root
(still the number 11) lacks the heap property:
22

22 17

19 11 14 15

18 14 21 3 9

 We can heapify() this node.

 After doing this, one and only one of its children may have
lost the heap property —but it doesn’t, because it’s a leaf.
THE HEAPIFY METHOD IV
 Our tree is once again a heap, because every node
in it has the heap property.
22

22 17

19 21 14 15

18 14 11 3 9

 Once again, the largest (or a largest) value is in the root.

 We can repeat this process until the tree becomes empty.

 This produces a sequence of values in order largest to smallest.

SORTING

 What do heaps have to do with sorting an array?

 Here’s the neat part:
Because the binary tree is balanced and left
justified, it can be represented as an array.
All our operations on binary trees can be
represented as operations on arrays.
To sort:
heapify the array;
while the array isn’t empty {
remove and replace the root;
reheap the new root node;
}
MAPPING INTO AN ARRAY
25

22 17

19 22 14 15

18 14 21 3 9 11

0 1 2 3 4 5 6 7 8 9 10 11 12
25 22 17 19 22 14 15 18 14 21 3 9 11
 Notice:
 The left child of index i is at index 2*i+1
 The right child of index i is at index 2*i+2
 Example: the children of node 19 ( index 3) are 18 (index 7) and 14
(index 8)
REMOVING AND REPLACING THE ROOT
 The “root” is the first element in the array.
 The “rightmost node at the deepest level” is the last element

 Swap them...

0 1 2 3 4 5 6 7 8 9 10 11 12
25 22 17 19 22 14 15 18 14 21 3 9 11

0 1 2 3 4 5 6 7 8 9 10 11 12
11 22 17 19 22 14 15 18 14 21 3 9 25

 ...And pretend that the last element in the array no

longer exists—that is, the “last index” is 11 (9)
REHEAP AND REPEAT
 Reheap the root node (index 0, containing 11)...
0 1 2 3 4 5 6 7 8 9 10 11 12
11 22 17 19 22 14 15 18 14 21 3 9 25

0 1 2 3 4 5 6 7 8 9 10 11 12
22 22 17 19 21 14 15 18 14 11 3 9 25

0 1 2 3 4 5 6 7 8 9 10 11 12
9 22 17 19 22 14 15 18 14 21 3 22 25

 ...And again, remove and replace the root node

 Remember, though, that the “last” array index is changed

 Repeat until the last becomes first, and the array is sorted!
 ANALYSIS I

 Here’s how the algorithm starts:

heapify the array;
 Heapifying the array: we add each of n nodes
Each node has to be Heapify, possibly as far as the
root.
Since the binary tree is perfectly balanced, sifting

up a single node takes O(log n) time.

Since we do this n times, heapifying takes n*O(log
n) time, that is, O(n log n) time.
ANALYSIS II

 Here’s the rest of the algorithm:

while the array isn’t empty {
remove and replace the root;
reheap the new root node;
}

 We do the while loop n times (actually, n-1 times),

because we remove one of the n nodes each time.

 Removing and replacing the root takes O(1) time.

 Therefore, the total time is n times however long it takes

the reheap method.
ANALYSIS III

 To reheap the root node, we have to follow one path

from the root to a leaf node (and we might stop before
we reach a leaf).
 The binary tree is perfectly balanced.

 Therefore, this path is O(log n) long:

And we only do O(1) operations at each node.

Therefore, reheaping takes O(log n) times.
 Since we reheap inside a while loop that we do n
times, the total time for the while loop is n*O(log n),
or O(n log n).
ANALYSIS IV

 Here’s the algorithm again:

heapify the array;
while the array isn’t empty {
remove and replace the root;
reheap the new root node;
}
 We have seen that heapifying takes O(n log n) time.
 The while loop takes O(n log n) time.

 The total time is therefore O(n log n) + O(n log n).

 This is the same as O(n log n) time.

THE END