1. Asst. Prof. Dr. İlker Kocabaş
Heapsort
Lecture 4
Asst. Prof. Dr. İlker Kocabaş

2. Sorting Algorithms Insertion sort Merge sort Quicksort Heapsort
Counting sort
Radix sort
Bucket sort
Order statistics

3. 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].

4. 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
LEFT(i)
return 2i
RIGHT(i)
return 2i+1

5. Heap property Two kinds of heap: Maximum heap and minimum heap.
Max-heap property is that for every node i other than the root
Min-heap property is that for every node i other than the root

6. Heap property
In both kinds, the values in the nodes satisfy the corresponding property (max-heap and min-heap properties)

7. A max-heap viewed as a binary tree
Heap property 1 16 3 2 10 14 4 5 6 7 8 7 9 5 8 9 10 11 3 4 1 4 4
A max-heap viewed as a binary tree

8. 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).

9. 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.
MAX-HEAP-INSERT
HEAP-EXTRACT-MAX
HEAP-INCREASE-KEY
HEAP-MAXIMUM

10. 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.

11. Maintaining the heap property

12. The action of MAX-HEAPY(A, 2) with heap-size[A]=10

13. The Running Time of MAX-HEAPIFY
• Fix up the relationships among the parent and children
• 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)

14. Building a heap We note that the elements in the subarray
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

15. Building a heap

16. Building a Heap(contnd.)

17. Buiding a Heap (contd.) • The running time is Running time:
• Each call to MAX-HEAPIFY costs O(lg n) time,
• There are O(n) such calls.
• The running time is
(not asymptotically tight.)

18. 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.

19. Maximum number of nodes at height h (n=11)
Buiding a Heap (contd.) 1
Maximum number of nodes at height h (n=11) 16 3 2 10 h
Actual # nodes 6 1 3 2 14 4 5 6 7 8 7 9 5 8 9 10 11 3 4 1 4 4

20. Buiding a Heap (contd.) Asymptotically tight bound (cont.)
Time required by MAX_HEAPIFY
when called on a node of height h is O(h)

21. Buiding a Heap (contd.)

22. Buiding a Heap (contd.)

23. The heapsort algorithm

24. The heapsort algorithm

25. 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.

26. 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.

27. The MAXIMUM operation
The procedure HEAP-MAXIMUM implements the MAXIMUM operation
HEAP-MAXIMUM(A)
1 return A[1]
T(n)=Θ(1)

28. 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

29. 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)]
i ← PARENT(i)

30. The operation of HEAP-INCREASE-KEY
Increasing the key=4 to15

31. The INSERT Operation MAX-HEAP-INSERT(A, key)
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)