gyvgvb

1. Performance Analysis of Heap Sort and Insertion Sort Algorithm
Humaira Ali, Haque Nawaz, Abdullah Maitlo, Inayatullah Soomro(2021)
Presented by:
Muhammad Sheraz ul Hassan (23201009-011)
Ali Imran Cheema (23201009-004)
Khuram Shahzad (23201009-002)

2. Table of contents
 ABSTRACT
 INTRODUCTION
 METHODOLOGY
 IMPLEMENTATION AND RESULT ANALYSIS
 CONCLUSION

3. ABSTRACT :
 Two types of sorting algorithm, Heap Sort and Insertion Sort and also their performance
analysis on the basis of running time along with their complexity.
 The comparison of these two sorting algorithms with different type of the data at running
time such as Large, Average, and Small. In Large, data pass100 integers in the array. For
Average data pass 50 integers in the array and for Small data pass10 integers in the array.
It checks that, which sorting technique is efficient according to the input data. Then
identifies the efficiency of these algorithms according to this data three cases used that is
Best, Average and Worst Case.
 The result of this analysis to show that how much time both algorithms take while given
the desired output.

4. INTRODUCTION:
 An algorithm can be used in both mathematical and computer science field. The
term sorting algorithm means arranging data in a certain/sequential order.
Whereas, both Heap Sort and Insertion Sort algorithms are comparison based
algorithms. Sorting algorithms are also classified as complexity of the algorithm
which includes (worst, average and best case) according to the size of the input
data, and check the stability how much memory is used.

5. Insertion Sort

6. Insertion Sort:
 Insertion sort divides the input data into sorted and unsorted data and then
compares the unsorted part with the sorted data, if the data in the unsorted part
is less than sort that data is in its accurate position.
 Insertion sort takes maximum time to sort if elements are sorted in reverse
order. And it takes minimum time (Order of n) when elements are already
sorted.
 Insertion sort is stable
 Insertion sort is inplace.

7. Algorithm:
The simple steps of achieving the insertion sort are listed as follows -
 Step 1 - If the element is the first element, assume that it is already sorted. Return
1.
 Step2 - Pick the next element, and store it separately in a key.
 Step3 - Now, compare the key with all elements in the sorted array.
 Step 4 - If the element in the sorted array is smaller than the current element, then
move to the next element. Else, shift greater elements in the array towards the
right.
 Step 5 - Insert the value.
 Step 6 - Repeat until the array is sorted.

8. Working of Insertion Sort algorithm:

9. Working of Insertion Sort algorithm:
4 3 2 10 12 1 5 6
3 4 2 10 12 1 5 6
4 3 2 10 12 1 5 6
Here, 4 is greater than 3 hence they are not in the ascending order and 4 is not at its correct position. Thus, swap 3 and
4. So, for now 3 is stored in a sorted sub-array.
First Pass:
Initially, the first two elements of the array are compared in insertion sort.
Second Pass:
Now, move to the next two elements which are 4 and 2
3 4 2 10 12 1 5 6
Both 4 and 2 are not present at their correct place so swap them

10. Now, elements are present in the sorted sub-array
Moving forward to the next two elements and 13 are not present at their correct place so swap them
3 2 4 10 12 1 5 6
2 3 4 10 12 1 5 6
2 3 4 10 12 1 5 6
2 3 4 10 12 1 5 6
After swapping, elements 3 and 2 are not sorted, thus swap again
Third Pass:
Now, elements are present in the sorted sub-array
Moving forward to the next two elements
Fourth Pass:
2 3 4 10 12 1 5 6

11. 2 3 4 10 12 1 5 6
Fifth pass:
Now, the elements which are present in the sorted sub-array are 2, 3, 4, 10 and 12
Moving to the next two elements 12and 1
2 3 4 10 12 1 5 6
Clearly, they are not sorted, thus perform swap between both
2 3 4 10 1 12 5 6
Now, 1 is smaller than 10, hence, swap again
2 3 4 1 10 12 5 6
Here, also swapping makes 4 and 1 unsorted hence, swap again
2 3 1 4 10 12 5 6

12. Now, 1 is smaller than 3, hence, swap again
2 1 3 4 10 12 5 6
Now, 1 is smaller than 2, hence, swap again
2 1 3 4 10 12 5 6
1 2 3 4 10 12 5 6
Sixth pass:
1 2 3 4 10 12 5 6
Now, the elements which are present in the sorted sub-array are 1, 2, 3, 4, 10 and 12
Moving to the next two elements 12 and 6
1 2 3 4 10 12 5 6
Clearly, they are not sorted, thus perform swap between both

13. 1 2 3 4 10 5 12 6
Now, 5 is smaller than 10, hence, swap again
1 2 3 4 5 10 12 6
Sixth pass:
1 2 3 4 5 10 12 6
The next two elements 12 and 6
1 2 3 4 5 10 12 6
Clearly, they are not sorted, thus perform swap between both
1 2 3 4 5 10 6 12
The next two elements 10 and 6. Clearly, they are not sorted, thus perform swap between both
1 2 3 4 5 6 10 12
Finally, the array is completely sorted

14. Insertion Sort
 Best case: When the input array is
already sorted, the time complexity
of Insertion Sort is O(n), as each
element is compared with the
previous one and shifted only once.

15. Insertion Sort
 Average case: In the average case, the
time complexity of Insertion Sort is
Θ(n^2), as for each element in the
unsorted portion of the array, it may
have to compare and shift up to half of
the sorted portion.

16. Insertion Sort
 Worst case: In the worst case, when the
input array is sorted in reverse order,
the time complexity of Insertion Sort is
also Θ(n^2), as each element has to be
compared and shifted all the way to the
beginning of the sorted portion.

17. Heap Sort

18. Heap Sort:
 Heap sort processes the elements by creating the min-heap or max-heap using the elements
of the given array. Min-heap or max-heap represents the ordering of array in which the root
element represents the minimum or maximum element of the array.
 Heap sort is a popular and efficient sorting algorithm. The concept of heap sort is to
eliminate the elements one by one from the heap part of the list, and then insert them into
the sorted part of the list.
 Heap sort is the in-place sorting algorithm.
 Heap sort is unstable.

19. Heap Sort Algorithm:
Here’s the algorithm for heap sort:
 Step 1: Build Heap. Build a heap from the input data. Build a max heap to sort in increasing
order, and build a min heap to sort in decreasing order.
 Step 2: Swap Root. Swap the root element with the last item of the heap.
 Step 3: Reduce Heap Size. Reduce the heap size by 1.
 Step 4: Re-Heapify. Heapify the remaining elements into a heap of the new heap size by calling
heapify on the root node.
 Step 5: Call Recursively. Repeat steps 2,3,4 as long as the heap size is greater than 2.

20. Heap Sort Working:
After building max-heap, the elements in the array will be:

21. Heap Sort Working:
4
7
5
3
1
8
Step 1:
8 is swapped with 5.
5
8
3
1
7
4
Step 2:
8 is disconnected from heap as 8 is in correct position now and.

22. Step 3:
Max-heap is created and 7 is swapped with 3. 7
4
7
1 3
8
Step 4:
7 is disconnected from heap.
3
8
1
5
4
5

23. Step 5:
Max heap is created and 5 is swapped with 1.
Step 6:
5 is disconnected from heap.
7 8
1
3
4
5
8
7
5
3
4
1

24. Step 7:
Max heap is created and 4 is swapped with 3.
Step 8:
4 is disconnected from heap.
8
7
5
3
1
4
8
7
5
4
1
3

25. Step 9:
Max heap is created and 3 is swapped with 1.
Step 10:
3 is disconnected.
4 5 8
7
1
3
5
4 7 8
3
4

26. 4 5 8
7
3
1
After all the steps, we will get a sorted array.

27. Heap Sort
 In Heap sort time
complexity for all
cases is O (n log n)

28. Phase I
Implementation
Phase II
Check Complexity
Phase III
Comparison
Phases

29. Working Mechanism Of Both Sorting Algorithms
Start
Make a set of data
Implementation
of Insert Sort
Insert the above data in array
Comparison of both algorithms
By Checking the run time
Check Complexity of the given data
Implementation
of Heap Sort
End

30. Phase I (Implementation)
 Both the algorithms insertion sort and heap sort is implemented in java programming
language. And the data is based on arrays. In both algorithms three types of data is tested that
is (Small, Average and large data) that is the length of the array. These three types of data set
are tested on three cases best, average and worst case. Table 1 presents data size.
Data Array Size
Small 10
Average 50
Large 100
Table 1: Data Set Size

31. Phase II (Check Complexity)
 In this phase, the complexity can be check in three ways:
 1. Best Case
 2. Average Case
 3. Worst Case
So according to these cases in best case the data in array is arranged in sequential order, in
average case the data in array is arranged in random order and in worst case the data in array
is arranged in decreasing order.

32. Analysis for Best Case:
The running time is depending on these input data. The running time of all these three cases is
different in both insertion sort and heap sort. Some data can take too much time and some data
take less time. So according to the running time check the complexity of these algorithms that
which algorithm is efficient for which type of data.
Figure 1: Represents small data in best case

33. Figure 2: Represent Average Data In Best Case.
Analysis for Best Case:

34. Figure 3: Represent Large Data In Best Case.
Analysis for Best Case:

35. Analysis for Average Case:
In the analysis of average case the data that is tested is in unsystematic form. The analysis can be
performing on large, small and average set of data
Figure 4: Represent Small Data In Average Case.

36. Analysis for Average Case:
Figure 5: Represent Large Data In Average Case.

37. Analysis for Average Case:
Figure 6: Represent Large Data In Average Case.

38. Analysis for Worst Case:
In the analysis of worst case the data that is tested is in decreasing form. The analysis can be
performing on large, small and average set of data
Figure 7: Represent Small Data In Worst Case

39. Analysis for Worst Case:
Figure 8: Represent Average Data In Worst Case.

40. Analysis for Worst Case:
Figure 9: Represent Large Data In Worst Case.

41. Phase III (Comparison)
In this phase the comparison of heap and insertion sort is performed by using the best, average and
worst case on small, large and average data set
Figure 14: Represent The Comparison of Insertion and Heap Sort on Small Data Set.

42. Phase III (Comparison)
Figure 15: Represent The Comparison of Insertion and Heap Sort on Average Data Set

43. Phase III (Comparison)
Figure 16: Represent The Comparison of Insertion and Heap Sort on Large Data Set.

44. Time Complexities
Insertion Sort Heap Sort
Best case: O (n) Best case: O (n log n)
Average case: Θ(n^2) Average case: O (n log n)
Worst case: Θ(n^2) Worst case: O (n log n)

45. RESULTS
 In the above analysis and comparison of both insertion sort and heap sort the
insertion sort has fast running time for small and average data and for large data
insertion sort takes too much time so according to this analysis insertion sort is use
for small and average data
 Heap sort takes less time than insertion sort in average and large data for both in
average and worst case and it has smaller difference in running time for large data
set so heap sort is best for large data in every case.
 According to these conditions it is clear that insertion sort takes less time in best
and average case for small and average data. But for large data the performance of
heap sort is good, so for large data use heap sort algorithm to save our time and
complete the tasks with in minimum time.