Scribd
Upload
4 views

Heap sort

Uploaded by

aThArvA SiNgh
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
4 views

Heap sort

Uploaded by

aThArvA SiNgh
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 24

APEX INSTITUTE OF TECHNOLOGY

Bachelor of Engineering (Computer Science &


Engineering)

Subject: Data Structure


Subject Code: 23CSH-241
Chapter: Tree
Subject Coordinator:
Ms. Upasana Tiwari
(E15791)

Tree
Lecture No.-3.1 DISCOVER . LEARN .
EMPOWER
Index
• Heap Data Structure
• Heap Operations
• Insertion in the Heap tree
• Deletion in Heap Tree

2 2
Heap Data Structure
Heap data structure is a complete binary tree that
satisfies the heap property, where any given node is
• always greater than or equal to its child node/s and the
key of the root node is the largest among all other
nodes. This property is also called max heap property.
A[Parent(i)] >= A[i]
• always smaller than or equal to the child node/s and
the key of the root node is the smallest among all other
nodes. This property is also called min heap property.
A[Parent(i)] <= A[i]
Operations of Heap
Data Structure
• Heapify: a process of creating a heap from an array.
• Insertion: process to insert an element in existing
heap time complexity O(log N).
• Deletion: deleting the top element of the heap or
the highest priority element, and then organizing
the heap and returning the element with time
complexity O(log N).
• Peek: to check or find the most prior element in the
heap, (max or min element for max and min heap).
Types of Heap Data
Structure
Generally, Heaps can be of two types:
• Max-Heap: In a Max-Heap the key present at the root
node must be greatest among the keys present at all
of it’s children. The same property must be recursively
true for all sub-trees in that Binary Tree.
A[Parent(i)] >= A[i]
• Min-Heap: In a Min-Heap the key present at the root
node must be minimum among the keys present at all
of it’s children. The same property must be recursively
true for all sub-trees in that Binary Tree.
A[Parent(i)] <= A[i]
Max Heap
• A[Parent(i)] >= A[i]
Min Heap
A[Parent(i)] <= A[i]
Heapify
Heapify is the process of creating a heap data
structure from a binary tree represented using an
array. It is used to create Min-Heap or Max-heap.
Start from the first index of the non-leaf node whose
index is given by n/2 – 1. Heapify uses recursion.
Algorithm for Heap
sort:
MaxHeapify(arr,i)
L = left(i)
R = right(i)
if L ? heap_size[arr] and arr[L] > arr[i]
largest = L
else
largest = i
if R ? heap_size[arr] and arr[R] > arr[largest]
largest = R
if largest != i
swap arr[i] with arr[largest]
MaxHeapify(arr,largest)
End
Continue..
BuildMaxHeap(arr)
heap_size(arr) = length(arr)
for i = length(arr)/2 to 1
MaxHeapify(arr,i)
End
Continue..
HeapSort(arr)
BuildMaxHeap(arr)
for i = length(arr) to 2
swap arr[1] with arr[i]
heap_size[arr] = heap_size[arr] ? 1
MaxHeapify(arr,1)
End
Working of Heap sort
Algorithm
In heap sort, basically, there are two phases involved
in the sorting of elements.
• The first step includes the creation of a heap by
adjusting the elements of the array.
• After the creation of heap, now remove the root
element of the heap repeatedly by shifting it to the
end of the array, and then store the heap structure
with the remaining elements.
Example Of Heap Sort
let's take an unsorted array

First, we have to construct a heap from the


given array and convert it into max heap.
Continue..

Next, we have to delete the root element (89)


from the max heap. To delete this node, we
have to swap it with the last node, i.e. (11).
After deleting the root element, we again have
to heapify it to convert it into max heap.
Continue..

After swapping the array element 89 with 11, and


converting the heap into max-heap, the elements of
array are –

In the next step, again, we have to delete the root


element (81) from the max heap. To delete this node,
we have to swap it with the last node, i.e. (54). After
deleting the root element, we again have to heapify it to
convert it into max heap.
Continue..
Let's see an example of inorder traversal. The nodes
with yellow color are not visited yet. Nodes with
green color are visited nodes

After swapping the array element 81 with 54 and


converting the heap into max-heap, the elements
of array are -
Continue..
In the next step, we have to delete the root element (76)
from the max heap again. To delete this node, we have to
swap it with the last node, i.e. (9). After deleting the root
element, we again have to heapify it to convert it into max
heap.
Continue..
• After swapping the array element 76 with 9 and converting the heap
into max-heap, the elements of array are -

In the next step, again we have to delete the root element (54) from the
max heap. To delete this node, we have to swap it with the last node,
i.e. (14). After deleting the root element, we again have to heapify it to
convert it into max heap.
Continue..
After swapping the array element 54 with 14 and converting
the heap into max-heap, the elements of array are -

In the next step, again we have to delete the root element


(22) from the max heap. To delete this node, we have to
swap it with the last node, i.e. (11). After deleting the root
element, we again have to heapify it to convert it into max
heap.
Continue..
After swapping the array element 22 with 11 and
converting the heap into max-heap, the elements
of array are -

In the next step, again we have to delete the root


element (14) from the max heap. To delete this
node, we have to swap it with the last node,
i.e. (9). After deleting the root element, we again
have to heapify it to convert it into max heap.
Continue..
After swapping the array element 14 with 9 and
converting the heap into max-heap, the elements
of array are -

In the next step, again we have to delete the root


element (11) from the max heap. To delete this
node, we have to swap it with the last node, i.e. (9).
After deleting the root element, we again have to
heapify it to convert it into max heap.
Continue..

After swapping the array element 11 with 9, the


elements of array are –

Now, heap has only one element left. After deleting


it, heap will be empty.

After completion of sorting, the array elements are –

Now, the array is completely sorted.


References
WEB LINKS
• https://www.geeksforgeeks.org/data-structures/
• https://www.javatpoint.com/data-structure-tutorial
• https://www.tutorialspoint.com/data_structures_al
gorithms/index.htm
VIDEO LINK
• https://www.youtube.com/watch?v=NzIGLLwZBS8
THANK YOU

24

You might also like