1/4/2023

Content
• Introduction to Heap
• Representation of Heap

DATA STRUCTURES • Operations on Heaps

• Insertion(item)
• Delete(item)
Heap
• Application of Heap
• Priority Queue
By • Heap Sort
Zainab Malik

3 4

Introduction to Heap Introduction to Heap: Max Heap vs. Min Heap

• A heap is binary tree that satisfies the following properties
• Shape property: Heap must be a complete binary tree
• Order property: It must be either Max heap or Min heap

• Max heap
• For every node in the heap, the value stored in that node is greater than
or equal to the value in each of its children
• Min heap
• For every node in the heap, the value stored in that node is less than or
equal to the value in each of its children

5 6

Heap Representation Operations on Heaps

• Heap is a Complete Binary Tree. This property of Binary • On heaps, only two operations are performed
Heap makes it suitable to be stored in a linear array. • Insertion
• Each node is assigned a numeric label and a node is • Deletion
stored in an array at a position with same index as its
associated label.

1
 1/4/2023

7 8

Heap Operation: Insertion(item) Heap Operation: Insertion(item)

• Item is always inserted as last (bottom) child of the original heap. • Insert(item,n,heap):
1. Set n=n+1
• After insertion, shape property remain undisturbed, but the order may
2. Set heap[n]=item
get violated if a larger item (incase of Max Heap) or smaller item
3. Call reheapifyUpward(heap n)
(incase of Min Heap) is inserted.
4. Return
• To satisfy the order property, heap needs to be readjusted in terms of
its structure (reheapifyUpward) • ReheapifyUpward(heap, start)
1. If heap[start] is not a root node then
• ReheapifyUpward: 2. If(heap[parent]<=heap[start]) then
• It involves moving the items up from the last (bottom) position until 3. Set index = index of the child with largest value
either it ends up in a position where the order property satisfied or it 4. Swap heap[parent] and heap[index]
hits the root node. 5. Call repheapifyUpward(heap, parent)
Endif
Endif
5. Return

9 10

Heap Operation: Insertion(item=90) Heap Operation: Deletion()

• Element is always deleted from the root of the heap
• When the element is deleted from the root, it creates a vacant
space in the root position
• As heap must be a complete binary tree, so the vacant space is
filled by last (bottom right) element of the heap
(a) (b) • Like insertion, this replacement ensures the shape property but
disturbs the order property that needs to be satisfied by mean of
reheapify (reheapifyDownward).

• reheapifyDownward:
• It involves moving the element down from the root position until
either it ends up in a position where order property is satisfied or it
hits the leaf node.
(c) (d)

11 12

Heap Operation: Deletion() Heap Operation: Deletion()

• Delete(n,heap):
1. Set item=heap[root]
2. Set heap[root]=heap[n]
3. Set n=n-1
4. Call reheapifyDownward(heap,root)
5. Return item

• ReheapifyDownward(heap, start) (a) (b)

1. If heap[start] is not a leaf node then
2. Set index = index of the child with largest value
3. If(heap[start]<=heap[index]) then
4. Swap heap[index] and heap[start]
5. Call repheapifyDownward(heap, index)
Endif
Endif
6. Return
(c) (d)

2
 1/4/2023

13 14

Applications of Heap Priority Queue using Heap

• Priority Queue • Each Node in a heap have two types of information i.e.
• Heap Sort the content and an associated priority
• Heap is build with respect to priority which means that the
element with highest priority will be at root node.
• As in heap we always delete from the root therefore,
whenever a node will be removed for processing it will be
of highest priority

15 16

Priority Heap Operation: Insertion(item) Priority Heap Operation: Deletion()

• Insert(item,n,heap)://item must be an object of Element containing • Delete(n,heap):
both content and priority 1. Set item=heap[root]
1. Set n=n+1 2. Set heap[root]=heap[n]
2. Set heap[n]=item 3. Set n=n-1
3. Call reheapifyUpward(heap n) 4. Call reheapifyDownward(heap,root)
4. Return 5. Return item

• ReheapifyUpward(heap, start) • ReheapifyDownward(heap, start)

1. If heap[start] is not a root node then 1. If heap[start] is not a leaf node then
2. If(heap[parent].priority<=heap[start].priority) then 2. Set index = index of the child with largest priority value
3. Set index = index of the child with largest priority value 3. If(heap[start].priority<=heap[index].priority) then
4. Swap heap[parent] and heap[index] 4. Swap heap[index] and heap[start]
5. Call repheapifyUpward(heap, parent) 5. Call repheapifyDownward(heap, index)
Endif Endif
Endif Endif
5. Return 6. Return

17 18

Applications of Heap Heap Sort

• Priority Queue • HeapSort(a,n) //𝑎 is a linear array and n is the last element of 𝑎
1. Call Heapify(a, n)
• Heap Sort
2. Repeat Step 3 and 4 For i=n to 1 in steps of -1
3. Swap elements a[1] with a[i]
4. Call ReheapifyDownward(a,1) (see slide # 11)
5. Endfor
6. Return

Heapify(a,n)
1. Set index=Parent of node with index n
2. Repeat step 3 For i=index to 1 in setp of -1
3. Call reheapifyDownward(a,i) (see slide # 8)
4. Endif
5. Return

3
 1/4/2023

19 20

Heap Sort Heap Sort

Unsorted Array • HeapSort(a,n) //𝑎 is a linear array and n is the last element of 𝑎
1 2 3 4 5 6 7 1. Call Heapify(a, n)
10 5 70 15 12 35 50 2. Repeat Step 3 and 4 For i=n to 1 in steps of -1
3. Swap elements a[1] with a[i]
4. Call ReheapifyDownward(a,1) on Heap from 1 to n-1 (see slide # 11)
5. Endfor
6. Return

Heapify(a,n)
1. Set index=Parent of node with index n
2. Repeat step 3 For i=index to 1 in setp of -1
3. Call reheapifyDownward(a,i) (see slide # 8)
4. Endif
5. Return
Equivalent Binary Tree

21 22

Unsorted Array Unsorted Array

1 2 3 4 5 6 7 1 2 3 4 5 6 7
10 5 70 15 12 35 50 10 5 15 70 15 5 12 35 50 Unsorted Array
1 2 3 4 5 6 7
70 15 50 5 12 35 10

Unsorted Array
1 2 3 4 5 6 7 Unsorted Array
1 2 3 4 5 6 7
10 70 15 70 10 5 12 35 50
70 15 10 50 5 12 35 50 10

23 24

Unsorted Unsorted Sorted

Heap Sort
1 2 3 4 5 6 7 1 2 3 4 5 6 7
70 15 50 5 12 35 10 50 15 10 5 12 35 70

• HeapSort(a,n) //𝑎 is a linear array and n is the last element of 𝑎

1. Call Heapify(a, n) 
2. Repeat Step 3 and 4 For i=n to 1 in steps of -1
3. Swap elements a[1] with a[i]
4. Call ReheapifyDownward(a,1) on Heap from 1 to n-1 (see slide # 11)
5. Endfor
6. Return

Heapify(a,n)
1. Set index=Parent of node with index n
2. Repeat step 3 For i=index to 1 in setp of -1
3. Call reheapifyDownwardward(a,i) (see slide # 8)
4. Endif
5. Return

4
 1/4/2023

25 26

Unsorted Sorted Unsorted Sorted

1 2 3 4 5 6 7 1 2 3 4 5 6 7
After First Iteration of
1. Repeat Step 3 and 4 For i=n to 1 in steps of -1 50 15 35 5 12 10 70 10 15 35 5 12 50 70
2. Swap elements a[1] with a[i]
3. Call ReheapifyDownward(a,1) on Heap from 1 to n-1 (see slide # 11)
4. Endfor

Unsorted Sorted
1 2 3 4 5 6 7
50 15 35 5 12 10 70

27 28

Unsorted Sorted Unsorted Sorted

After second Iteration of 1 2 3 4 5 6 7 1 2 3 4 5 6 7
1. Repeat Step 3 and 4 For i=n to 1 in steps of -1 35 15 10 5 12 50 70 12 15 10 5 35 50 70
2. Swap elements a[1] with a[i]
3. Call ReheapifyDownward(a,1) on Heap from 1 to
n-1 (see slide # 11)
4. Endfor

Unsorted Sorted
1 2 3 4 5 6 7
35 15 10 5 12 50 70

29 30

Unsorted Array Sorted Unsorted Array Sorted

After Third Iteration of 1 2 3 4 5 6 7 1 2 3 4 5 6 7

1. Repeat Step 3 and 4 For i=n to 1 in steps of -1 15 12 10 5 35 50 70 5 12 10 15 35 50 70
2. Swap elements a[1] with a[i]
3. Call ReheapifyDownward(a,1) (see slide # 11)
4. Endfor

Unsorted Sorted
1 2 3 4 5 6 7
15 12 10 5 35 50 70

5
 1/4/2023

31 32

Unsorted Sorted Unsorted Sorted

After 4th Iteration of 1 2 3 4 5 6 7 1 2 3 4 5 6 7
1. Repeat Step 3 and 4 For i=n to 1 in steps of -1 12 5 10 15 35 50 70 10 5 12 15 35 50 70
2. Swap elements a[1] with a[i]
3. Call ReheapifyDownward(a,1) (see slide # 11)
4. Endfor

Unsorted Sorted
1 2 3 4 5 6 7 Unsorted Sorted
12 5 10 15 35 50 70 1 2 3 4 5 6 7
10 5 12 15 35 50 70

After 5th Iteration of

12 1. Repeat Step 3 and 4 For i=n to 2 in steps of -1
1 2. Swap elements a[1] with a[i]
5 10 3. Call ReheapifyDownward(a,1,i-1) (see slide # 11)
4. Endfor
2 3

33 34

Unsorted Sorted Unsorted Sorted

1 2 3 4 5 6 7 1 2 3 4 5 6 7
10 5 12 15 35 50 70 5 10 12 15 35 50 70

Another Example of Heapsort

https://www.cs.usfca.edu/~galles/visualization/HeapSort.html

After 6th Iteration of

1. Repeat Step 3 and 4 For i=n to 1 in steps of -1
2. Swap elements a[1] with a[i]
3. Call ReheapifyDownward(a,1) (see slide # 11)
4. Endfor Sorted Array
1 2 3 4 5 6 7
5 10 12 15 35 50 70

35

Thank You