SlideShare a Scribd company logo

Heap Sort.ppx

Download as PPTX, PDF
S
Santi Brata Nath Joy

The document provides a detailed explanation of the heap sort algorithm, including its history, definitions, and the steps involved in executing the algorithm. It outlines key concepts like building a max heap, the procedure of heapifying an array, and implementing the sort through pseudocode. The content is structured academically for a computer science course, making it suitable for students learning sorting algorithms.

Engineering
Related topics:
data-structure
1 of 46
Download to read offline
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
TOPIC: HEAP SORT Group: 12 Date: 13/09/2022 COURSE : CSE 2218/CSI 228 (C) Faculty: Sufi Aurangzeb Hossain LECTURER (ADJUNCT) DEPT. OF COMPUTER SCIENCE & ENGINEERING 011201230 Santi Brata Nath Joy 011201295 Md. Tanzid Ahsan MEMBERS 011201214 Saikat Hossain
HISTORY Sir John William Joseph Williams 1964 Instant Access
DEFINATION Sorting Algorithm Binary Tree Heap O (N log N)
HEAP BINARY TREE 1 3 2 4 6 5 7 8 1 2 3 4 5 9 6 7 8 9 5 Index Data 6 7 8 9 5 6 7 8 3 2 4 1 0 1 2 3 4
HEAP PROPERTY Max Heap Min Heap 10 5 3 4 1 1 3 5 4 7 A[Parent(i)] ≥ A[i] A[Parent(i)] ≤ A[i] 3 5 4 1 10 0 1 2 3 4 Index Data 5 3 4 7 1 0 1 2 3 4
PROCEDURES OF HEAP SORT Heapify Heap Sort Build Heap Construct Binary Tree
HEAPIFY Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } 4 10 3 10 4 3 Swap
BUILD HEAP 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 3 5 1 Internal Nodes Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 //down to 0 do Heapify(A, i) }
BUILD HEAP Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 //down to 0 do Heapify(A, i) } 3 5 4 1 10 0 1 2 3 4 Index Data 10 5 3 4 1
HEAP SORT Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) } 0 1 2 3 4 4 3 5 10 1 Index Data 3 5 4 1 10 0 1 2 3 4 Index Data 0 1 2 3 4 3 5 4 1 10 Index Data Swap 0 1 2 3 4 3 5 4 10 1 Index Data
METHOD Heap Sort Construct Binary Tree Build Heap
SIMULATION PARENT (i) return floor(i/2) LEFT (i) return 2i RIGHT (i) return 2i + 1 3 10 5 1 4 0 1 2 3 4 Index Data
SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 PARENT (i) return floor(i/2) LEFT (i) return 2i RIGHT (i) return 2i + 1
SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 PARENT (i) return floor(i/2) LEFT (i) return 2i RIGHT (i) return 2i + 1
SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 3 PARENT (i) return floor(i/2) LEFT (i) return 2i RIGHT (i) return 2i + 1
SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 3 5 PARENT (i) return floor(i/2) LEFT (i) return 2i RIGHT (i) return 2i + 1
SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 3 5 1 Done PARENT (i) return floor(i/2) LEFT (i) return 2i RIGHT (i) return 2i + 1
SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 3 5 1 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 3 5 1 10 is greater than 4 then swap A[i] <-A[largest] Swap 4 and 10 Swap Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 3 4 5 1 10 0 1 2 3 4 Index Data 10 4 3 5 1 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 3 4 5 1 10 0 1 2 3 4 Index Data 5 is greater than 4 then swap A[i] <-A[largest] Swap 5 and 4 10 4 3 5 1 Swap Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 3 5 4 1 10 0 1 2 3 4 Index Data 10 5 3 4 1 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 3 5 4 1 10 0 1 2 3 4 Index Data 10 5 3 4 1 After Build Heap Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 5 4 1 10 Index Data 10 5 3 4 1 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] //down to 2 do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 5 4 1 10 Index Data 10 5 3 4 1 Swap Swapping the first element with the last element of unsorted array Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 5 4 10 1 Index Data 1 5 3 4 10 Deleting the last element as sorted Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 5 4 10 1 Index Data 1 5 3 4 Sorted Array Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 5 4 10 1 Index Data 1 5 3 4 Calling Heapify Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 5 4 10 1 Index Data 1 5 3 4 5 is greater than 1 then swap A[i] <-A[largest] Swap 5 and 1 Swap Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 1 4 10 5 Index Data 5 1 3 4 5 is greater than 1 then swap A[i] <-A[largest] Swap 5 and 1 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 1 4 10 5 Index Data 5 1 3 4 4 is greater than 1 then swap A[i] <-A[largest] Swap 4 and 1 Swap Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 4 1 10 5 Index Data 5 4 3 1 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
Swap SIMULATION 0 1 2 3 4 3 4 1 10 5 Index Data 5 4 3 1 Swapping the first element with the last element of unsorted array and delete the last element as sorted Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] //down to 2 do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 4 5 10 1 Index Data 1 4 3 Sorted Array Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 4 5 10 1 Index Data 1 4 3 4 is greater than 1 then swap A[i] <-A[largest] Swap 4 and 1 Swap Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 1 5 10 4 Index Data 4 1 3 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 3 1 5 10 4 Index Data 4 1 3 Swap Swapping the first element with the last element of unsorted array and delete the last element as sorted Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
SIMULATION 0 1 2 3 4 4 1 5 10 3 Index Data 3 1 Build Heap Max Heap Sort Continue…
SIMULATION 0 1 2 3 4 4 3 5 10 1 Index Data The array is sorted
Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) } TIME COMPLEXITY ANALYSIS O (N) O(log N) O (N log N) (n – 1) O(N log N)
SPACE COMPLEXITY ANALYSIS O (1)
APPLICATION
ADVANTAGES • No quadratic worst-case run time. • In-place sorting algorithm, performs sorting in O(1) space complexity. • Compared to quicksort, it has a better worst-case time complexity – O(NlogN). • The best-case complexity is the same for both quick and heap sort – O(NlogN). • Unlike merge sort, it doesn’t require extra space. • The input data being completely or almost sorted doesn’t make the complexities suffer. • The average-case time complexity is the same as that of merge quick and quick sort
DISADVANTAGES • Heap sort is typically not stable since the operations on the top can change the relative order of equal key items. It’s typically an unstable algorithm. • If the input array is very large and doesn’t fit into the memory and partitioning the array is faster than maintaining the heap, heap sort isn’t an option. In such cases, something like merge sort or bucket sort where parts of the array can be processed separately and parallelly, works best.
Thank you
Doubts?

More Related Content

PPTX
Algorithms - "heap sort"
Ra'Fat Al-Msie'deen
 
PPT
chapter - 6.ppt
Tareq Hasan
 
PPT
lecture 6
sajinsc
 
PPT
Algorithm: priority queue
Tareq Hasan
 
PPT
Heaps
Hafiz Atif Amin
 
PPTX
Sorting techniques
JayeshGadhave1
 
PPTX
Array ADT(Abstract Data Type)|Data Structure
Akash Gaur
 
PPT
lecture 5
sajinsc
 
Algorithms - "heap sort"
Ra'Fat Al-Msie'deen
 
chapter - 6.ppt
Tareq Hasan
 
lecture 6
sajinsc
 
Algorithm: priority queue
Tareq Hasan
 
Heaps
Hafiz Atif Amin
 
Sorting techniques
JayeshGadhave1
 
Array ADT(Abstract Data Type)|Data Structure
Akash Gaur
 
lecture 5
sajinsc
 

More from Santi Brata Nath Joy (7)

PPTX
Defence Presentation United International University.pptx
Santi Brata Nath Joy
 
PPTX
Camera Ready Submission Oral Presentation.pptx
Santi Brata Nath Joy
 
PPTX
Pre-Defence Presentation.pptx
Santi Brata Nath Joy
 
PPTX
UIU Recruiter Project Proposal.pptx
Santi Brata Nath Joy
 
PPTX
Entrepreneurship
Santi Brata Nath Joy
 
PDF
Android architecture
Santi Brata Nath Joy
 
PDF
Android
Santi Brata Nath Joy
 
Defence Presentation United International University.pptx
Santi Brata Nath Joy
 
Camera Ready Submission Oral Presentation.pptx
Santi Brata Nath Joy
 
Pre-Defence Presentation.pptx
Santi Brata Nath Joy
 
UIU Recruiter Project Proposal.pptx
Santi Brata Nath Joy
 
Entrepreneurship
Santi Brata Nath Joy
 
Android architecture
Santi Brata Nath Joy
 
Android
Santi Brata Nath Joy
 
Ad

Recently uploaded (20)

PDF
The CXO Playbook 2025 – Future-Ready Strategies for C-Suite Leaders Cerebrai...
Cerebraix Technologies
 
PDF
Mitigating Risks through Effective Management for Enhancing Organizational Pe...
IJAEMSJORNAL
 
PDF
Model Code of Practice - Construction Work - 21102022 .pdf
AinieButt1
 
PPTX
MET 305 2019 SCHEME MODULE 2 COMPLETE.pptx
VinayB68
 
PDF
PPT on Performance Review to get promotions
prashant593122
 
PPTX
CYBER-CRIMES AND SECURITY A guide to understanding
Davies Chacko
 
PDF
Operating System & Kernel Study Guide-1 - converted.pdf
mranoninvisib16
 
DOCX
ASol_English-Language-Literature-Set-1-27-02-2023-converted.docx
AYUSHMANAV
 
PPTX
FINAL REVIEW FOR COPD DIANOSIS FOR PULMONARY DISEASE.pptx
rubeshbme
 
PPTX
KTU 2019 -S7-MCN 401 MODULE 2-VINAY.pptx
VinayB68
 
PDF
Automation-in-Manufacturing-Chapter-Introduction.pdf
pcmth867
 
PDF
R24 SURVEYING LAB MANUAL for civil enggi
MNANDITHACIVILSTAFF
 
PPTX
additive manufacturing of ss316l using mig welding
premcdr7799
 
PPTX
Recipes for Real Time Voice AI WebRTC, SLMs and Open Source Software.pptx
Alberto González Trastoy
 
PPTX
CARTOGRAPHY AND GEOINFORMATION VISUALIZATION chapter1 NPTE (2).pptx
abhi1361yadav
 
PPTX
Geodesy 1.pptx...............................................
abhi1361yadav
 
PDF
July 2025 - Top 10 Read Articles in International Journal of Software Enginee...
sebastianku31
 
PPTX
UNIT 4 Total Quality Management .pptx
gokuld13012005
 
PDF
Digital Logic Computer Design lecture notes
CHINNASUNKAIAH1
 
PDF
SM_6th-Sem__Cse_Internet-of-Things.pdf IOT
smceramu
 
The CXO Playbook 2025 – Future-Ready Strategies for C-Suite Leaders Cerebrai...
Cerebraix Technologies
 
Mitigating Risks through Effective Management for Enhancing Organizational Pe...
IJAEMSJORNAL
 
Model Code of Practice - Construction Work - 21102022 .pdf
AinieButt1
 
MET 305 2019 SCHEME MODULE 2 COMPLETE.pptx
VinayB68
 
PPT on Performance Review to get promotions
prashant593122
 
CYBER-CRIMES AND SECURITY A guide to understanding
Davies Chacko
 
Operating System & Kernel Study Guide-1 - converted.pdf
mranoninvisib16
 
ASol_English-Language-Literature-Set-1-27-02-2023-converted.docx
AYUSHMANAV
 
FINAL REVIEW FOR COPD DIANOSIS FOR PULMONARY DISEASE.pptx
rubeshbme
 
KTU 2019 -S7-MCN 401 MODULE 2-VINAY.pptx
VinayB68
 
Automation-in-Manufacturing-Chapter-Introduction.pdf
pcmth867
 
R24 SURVEYING LAB MANUAL for civil enggi
MNANDITHACIVILSTAFF
 
additive manufacturing of ss316l using mig welding
premcdr7799
 
Recipes for Real Time Voice AI WebRTC, SLMs and Open Source Software.pptx
Alberto González Trastoy
 
CARTOGRAPHY AND GEOINFORMATION VISUALIZATION chapter1 NPTE (2).pptx
abhi1361yadav
 
Geodesy 1.pptx...............................................
abhi1361yadav
 
July 2025 - Top 10 Read Articles in International Journal of Software Enginee...
sebastianku31
 
UNIT 4 Total Quality Management .pptx
gokuld13012005
 
Digital Logic Computer Design lecture notes
CHINNASUNKAIAH1
 
SM_6th-Sem__Cse_Internet-of-Things.pdf IOT
smceramu
 
Ad

Heap Sort.ppx

  • 1. TOPIC: HEAP SORT Group: 12 Date: 13/09/2022 COURSE : CSE 2218/CSI 228 (C) Faculty: Sufi Aurangzeb Hossain LECTURER (ADJUNCT) DEPT. OF COMPUTER SCIENCE & ENGINEERING 011201230 Santi Brata Nath Joy 011201295 Md. Tanzid Ahsan MEMBERS 011201214 Saikat Hossain
  • 2. HISTORY Sir John William Joseph Williams 1964 Instant Access
  • 4. HEAP BINARY TREE 1 3 2 4 6 5 7 8 1 2 3 4 5 9 6 7 8 9 5 Index Data 6 7 8 9 5 6 7 8 3 2 4 1 0 1 2 3 4
  • 5. HEAP PROPERTY Max Heap Min Heap 10 5 3 4 1 1 3 5 4 7 A[Parent(i)] ≥ A[i] A[Parent(i)] ≤ A[i] 3 5 4 1 10 0 1 2 3 4 Index Data 5 3 4 7 1 0 1 2 3 4
  • 6. PROCEDURES OF HEAP SORT Heapify Heap Sort Build Heap Construct Binary Tree
  • 7. HEAPIFY Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } 4 10 3 10 4 3 Swap
  • 8. BUILD HEAP 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 3 5 1 Internal Nodes Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 //down to 0 do Heapify(A, i) }
  • 9. BUILD HEAP Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 //down to 0 do Heapify(A, i) } 3 5 4 1 10 0 1 2 3 4 Index Data 10 5 3 4 1
  • 10. HEAP SORT Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) } 0 1 2 3 4 4 3 5 10 1 Index Data 3 5 4 1 10 0 1 2 3 4 Index Data 0 1 2 3 4 3 5 4 1 10 Index Data Swap 0 1 2 3 4 3 5 4 10 1 Index Data
  • 12. SIMULATION PARENT (i) return floor(i/2) LEFT (i) return 2i RIGHT (i) return 2i + 1 3 10 5 1 4 0 1 2 3 4 Index Data
  • 13. SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 PARENT (i) return floor(i/2) LEFT (i) return 2i RIGHT (i) return 2i + 1
  • 14. SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 PARENT (i) return floor(i/2) LEFT (i) return 2i RIGHT (i) return 2i + 1
  • 15. SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 3 PARENT (i) return floor(i/2) LEFT (i) return 2i RIGHT (i) return 2i + 1
  • 16. SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 3 5 PARENT (i) return floor(i/2) LEFT (i) return 2i RIGHT (i) return 2i + 1
  • 17. SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 3 5 1 Done PARENT (i) return floor(i/2) LEFT (i) return 2i RIGHT (i) return 2i + 1
  • 18. SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 3 5 1 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 19. SIMULATION 3 10 5 1 4 0 1 2 3 4 Index Data 4 10 3 5 1 10 is greater than 4 then swap A[i] <-A[largest] Swap 4 and 10 Swap Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 20. SIMULATION 3 4 5 1 10 0 1 2 3 4 Index Data 10 4 3 5 1 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 21. SIMULATION 3 4 5 1 10 0 1 2 3 4 Index Data 5 is greater than 4 then swap A[i] <-A[largest] Swap 5 and 4 10 4 3 5 1 Swap Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 22. SIMULATION 3 5 4 1 10 0 1 2 3 4 Index Data 10 5 3 4 1 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 23. SIMULATION 3 5 4 1 10 0 1 2 3 4 Index Data 10 5 3 4 1 After Build Heap Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 24. SIMULATION 0 1 2 3 4 3 5 4 1 10 Index Data 10 5 3 4 1 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] //down to 2 do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 25. SIMULATION 0 1 2 3 4 3 5 4 1 10 Index Data 10 5 3 4 1 Swap Swapping the first element with the last element of unsorted array Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 26. SIMULATION 0 1 2 3 4 3 5 4 10 1 Index Data 1 5 3 4 10 Deleting the last element as sorted Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 27. SIMULATION 0 1 2 3 4 3 5 4 10 1 Index Data 1 5 3 4 Sorted Array Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 28. SIMULATION 0 1 2 3 4 3 5 4 10 1 Index Data 1 5 3 4 Calling Heapify Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 29. SIMULATION 0 1 2 3 4 3 5 4 10 1 Index Data 1 5 3 4 5 is greater than 1 then swap A[i] <-A[largest] Swap 5 and 1 Swap Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 30. SIMULATION 0 1 2 3 4 3 1 4 10 5 Index Data 5 1 3 4 5 is greater than 1 then swap A[i] <-A[largest] Swap 5 and 1 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 31. SIMULATION 0 1 2 3 4 3 1 4 10 5 Index Data 5 1 3 4 4 is greater than 1 then swap A[i] <-A[largest] Swap 4 and 1 Swap Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 32. SIMULATION 0 1 2 3 4 3 4 1 10 5 Index Data 5 4 3 1 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 33. Swap SIMULATION 0 1 2 3 4 3 4 1 10 5 Index Data 5 4 3 1 Swapping the first element with the last element of unsorted array and delete the last element as sorted Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] //down to 2 do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 34. SIMULATION 0 1 2 3 4 3 4 5 10 1 Index Data 1 4 3 Sorted Array Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 35. SIMULATION 0 1 2 3 4 3 4 5 10 1 Index Data 1 4 3 4 is greater than 1 then swap A[i] <-A[largest] Swap 4 and 1 Swap Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 36. SIMULATION 0 1 2 3 4 3 1 5 10 4 Index Data 4 1 3 Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 37. SIMULATION 0 1 2 3 4 3 1 5 10 4 Index Data 4 1 3 Swap Swapping the first element with the last element of unsorted array and delete the last element as sorted Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) }
  • 38. SIMULATION 0 1 2 3 4 4 1 5 10 3 Index Data 3 1 Build Heap Max Heap Sort Continue…
  • 39. SIMULATION 0 1 2 3 4 4 3 5 10 1 Index Data The array is sorted
  • 40. Heapify(A, i) { l <- left(i) r <- right(i) if l <= heapsize[A] and A[l] > A[i] then largest <- l else largest <- i if r <= heapsize[A] and A[r] > A[largest] then largest <- r if largest != i then swap A[i] <-A[largest] Heapify(A, largest) } Buildheap(A) { heapsize[A] length[A] for i |length[A]/2 do Heapify(A, i) } Heapsort(A) { Buildheap(A) for i  length[A] do swap A[1]  A[i] heapsize[A]  heapsize[A] - 1 Heapify(A, 1) } TIME COMPLEXITY ANALYSIS O (N) O(log N) O (N log N) (n – 1) O(N log N)
  • 43. ADVANTAGES • No quadratic worst-case run time. • In-place sorting algorithm, performs sorting in O(1) space complexity. • Compared to quicksort, it has a better worst-case time complexity – O(NlogN). • The best-case complexity is the same for both quick and heap sort – O(NlogN). • Unlike merge sort, it doesn’t require extra space. • The input data being completely or almost sorted doesn’t make the complexities suffer. • The average-case time complexity is the same as that of merge quick and quick sort
  • 44. DISADVANTAGES • Heap sort is typically not stable since the operations on the top can change the relative order of equal key items. It’s typically an unstable algorithm. • If the input array is very large and doesn’t fit into the memory and partitioning the array is faster than maintaining the heap, heap sort isn’t an option. In such cases, something like merge sort or bucket sort where parts of the array can be processed separately and parallelly, works best.