chapter 7: sorting algorithms insertion sort. sorting algorithms insertion sort shell sort heap...
TRANSCRIPT
![Page 1: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/1.jpg)
Chapter 7: Chapter 7: Sorting Sorting AAlgorithmslgorithms
Insertion Sort
![Page 2: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/2.jpg)
Sorting Algorithms
Insertion SortShell SortHeap SortMerge SortQuick Sort
2
![Page 3: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/3.jpg)
Assumptions
Elements to sort are placed in arrays of length N
Can be compared
Sorting can be performed in main memory
3
![Page 4: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/4.jpg)
Complexity
Simple sorting algorithms : O(N2)Shellsort: o(N2)Advanced sorting algorithms: O(NlogN)In general: Ω(NlogN)
4
![Page 5: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/5.jpg)
Insertion Sort
5
PRE: array of N elements (from 0 to N-1)
POST: array sorted
1. An array of one element is sorted
2. Assume that the first p elements are sorted.
for j = p to N-1
Take the j-th element and find a place for it among the first j sorted elements
![Page 6: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/6.jpg)
Insertion Sort
6
int j, p; comparable tmp;
for ( p = 1; p < N ; p++) {
tmp = a[p];
for ( j=p; j>0 && tmp < a[ j-1 ] ; j- - )
a[ j ] = a[ j-1 ];
a[ j ] = tmp; }
http://www.cs.auckland.ac.nz/software/AlgAnim/sorting.html#bubble
![Page 7: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/7.jpg)
Analysis of the Insertion Sort
7
Insert the N-th el.: at most N-1 comparisons N-1 movements
Insert the N-1st el. at most N-2 comparisons N-2 movements
Insert the 2nd el.: 1 comparison 1 movement
2*(1 + 2 +… N - 1) = 2*N * (N-1) / 2 =
N(N-1) = Θ (N2) Almost sorted array: O(N) Average complexity: Θ (N2)
![Page 8: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/8.jpg)
A lower bound for simple sorting algorithms
8
• An inversion :
an ordered pair (Ai, Aj) such that
i < j but Ai > Aj
Example: 10, 6, 7, 15, 3,1 Inversions are: (10,6), (10,7), (10,3), (10,1), (6,3), (6,1)(7,3), (7,1) (15,3), (15,1), (3,1)
![Page 9: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/9.jpg)
Swapping
9
Swapping adjacent elements that are out of order removes one inversion. A sorted array has no inversions.
Sorting an array that contains i inversions requires at least i swaps of adjacent elements
How many inversions are there in an average unsorted array?
![Page 10: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/10.jpg)
Theorems
10
Theorem 1: The average number of inversions in an array of N distinct elements is
N (N - 1) / 4
Theorem 2: Any algorithm that sorts by exchanging adjacent elements requires Ω (N2) time on average.
For a sorting algorithm to run in less than quadratic time it must do something other than swap adjacent elements
![Page 11: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/11.jpg)
Shell Sort
![Page 12: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/12.jpg)
Shell Sort
Improves on insertion sort
Compares elements far apart, then less far apart, finally compares adjacent elements (as an insertion sort).
12
![Page 13: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/13.jpg)
Idea
arrange the data sequence in a two-dimensional array
sort the columns of the array
repeat the process each time with smaller number of columns
13
![Page 14: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/14.jpg)
Example
14
3 7 9 0 5 1 6 8 4 2 0 6 1 5 7 3 4 9 8 2
it is arranged in an array with 7 columns (left),
then the columns are sorted (right): 3 7 9 0 5 1 6 3 3 2 0 5 1 5
8 4 2 0 6 1 5 7 4 4 0 6 1 6
7 3 4 9 8 2 8 7 9 9 8 2
![Page 15: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/15.jpg)
Example (cont)
15
3 3 2 0 0 1
0 5 1 1 2 2
5 7 4 3 3 4
4 0 6 4 5 6
1 6 8 5 6 8
7 9 9 7 7 9
8 2 8 9
one column in the last step –
it is only a 6, an 8 and a 9 that have to move a little bit to their correct position
![Page 16: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/16.jpg)
Implementation
16
• one-dimensional array that is
indexed appropriately.
• an increment sequence
to determine how far apart elements to be sorted are
![Page 17: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/17.jpg)
Increment sequence
17
Determines how far apart elements to be sorted are:
h1, h2, ..., ht with h1 = 1
hk-sorted array - all elements spaced a distance hk apart are sorted relative to each other.
![Page 18: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/18.jpg)
Correctness of the algorithm
18
Shellsort only works because an array
that is hk-sorted remains hk-sorted
when hk- 1-sorted.
Subsequent sorts do not undo the work done by previous phases.
The last step (with h = 1) -
Insertion Sort on the whole array
![Page 19: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/19.jpg)
Java code for Shell sort
19
int j, p, gap; comparable tmp;
for (gap = N/2; gap > 0; gap = gap/2)
for ( p = gap; p < N ; p++) { tmp = a[p];
for ( j = p ; j >= gap && tmp < a[ j- gap ];
j = j - gap) a[ j ] = a[ j - gap ];
a[j] = tmp;
}
![Page 20: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/20.jpg)
Increment sequences
20
1. Shell's original sequence:
N/2 , N/4 , ..., 1 (repeatedly divide by 2).
2. Hibbard's increments:
1, 3, 7, ..., 2k - 1 ;
3. Knuth's increments:
1, 4, 13, ..., ( 3k - 1) / 2 ;
4. Sedgewick's increments:
1, 5, 19, 41, 109, ....
9 ·4k - 9 ·2k + 1 or 4k - 3 ·2k + 1.
![Page 21: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/21.jpg)
Analysis
21
Shellsort's worst-case performance using Hibbard's increments is Θ(n3/2).
The average performance is thought to be about O(n 5/4)
The exact complexity of this algorithm is still being debated .
for mid-sized data : nearly as well if not better than the faster (n log n) sorts.
![Page 22: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/22.jpg)
Heap Sort
![Page 23: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/23.jpg)
Heap Sort
Basic IdeaComplexityExample
http://www.cs.auckland.ac.nz/software/AlgAnim/heapsort.html
23
![Page 24: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/24.jpg)
Idea
Store N elements in a binary heap tree.Perform delete_Min operation N times,
storing each element deleted from the heap into another array.
Copy back the array.
• Not very efficient to use two arrays.• Improvement – use one array for the binary heap
and the sorted elements
24
![Page 25: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/25.jpg)
Improvements
Use the same array to store the deleted elements instead of using another array
After each deletion we get a vacant position in the array - the last cell.
There we store the deleted element, which becomes part of the sorted sequence.
25
![Page 26: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/26.jpg)
Improvements
When all the elements are deleted and stored in the same array following the above method, the elements will be there in reversed order.
What is the remedy for this?Store the elements in the binary heap tree in
reverse order of priority - then at the end the elements in the array will be in correct order.
26
![Page 27: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/27.jpg)
Complexity
Sorts in O(NlogN) time by performing N times deleteMax operations.- Each deleteMax operation takes log N running
time.- N times performing deleteMax NlogN
running time
Used for general purpose sorting, guarantees O(N logN)
27
![Page 28: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/28.jpg)
Example
28
15 19 10 7 17 16
1. Consider the values of the elements as
priorities and build the heap tree.
2. Start deleteMax operations, storing
each deleted element at the end of the
heap array.
![Page 29: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/29.jpg)
Example (cont)
29
Note that we use only one array , treating its parts differently:
when sorting, part of the array will be the heap, and the rest part - the sorted array
![Page 30: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/30.jpg)
Build the Heap
30
We start with the element at position SIZE/2comparing the item with the children.The hole is percolated down to position 6 and the item is inserted there.
15 19 7 17 16
10
Result:
15 19 16 7 17 10
hole child
![Page 31: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/31.jpg)
Build the Heap
31
Next we compare position 2 with its children.
15 16 7 17 10
19
hole child1 child2
19 is greater than 7 and 17,
and we continue with position 1
15 19 16 7 17 10
![Page 32: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/32.jpg)
Build the Heap
32
Percolate down the hole at position 1
19 16 7 17 10
15
The hole at position 1 is percolated down to position 2 -the greater child.
19 16 7 17 10
15
![Page 33: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/33.jpg)
Build the Heap
33
Percolate down the hole at position 2
19 16 7 17 10
15
One of the children of the hole at position 2 - item 17, is greater than 15.
So we percolate the hole to position 5.19 17 16 7 15 10
![Page 34: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/34.jpg)
Build the Heap
34
19 17 16 7 15 10
19
17 16
7 15 10
the heap is built
![Page 35: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/35.jpg)
Sorting
35
DeleteMax the top element 19
17 16 7 15 19
17 16
7 15
Store the last heap element (10) in a temporary place.
Move the DeletedMax element (19) to the place where the last heap element was - the current available position in the sorted portion of the array.A hole is created at the top
10
![Page 36: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/36.jpg)
Sorting
36
Percolate down the hole
16 7 15 19
16
7 15
10
17
17
![Page 37: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/37.jpg)
Sorting
37
Percolate down the hole
16 715 19
16
7
15
10
17
17
![Page 38: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/38.jpg)
Sorting
38
Fill the hole
16 715 19
10
16
7
15
1017
17
![Page 39: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/39.jpg)
Sorting
39
DeleteMax the top element 17
16 715 19
16
7
15
17
10
Store the last heap element (10) in a temporary place.
Move the DeletedMax element (17) to the place where the last heap element was - the current available position in the sorted portion of the array.A hole is created at the top
![Page 40: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/40.jpg)
Sorting
40
Percolate down the hole
16 715 19
16
7
15
17
10
![Page 41: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/41.jpg)
Sorting
41
Fill the hole
16 715 19
10
16
7
15
1710
![Page 42: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/42.jpg)
Sorting
42
DeleteMax the top element 16
1615 19
1015
1710
Store the last heap element (7) in a temporary place.
Move the DeletedMax element (16) to the place where the last heap element was - the current available position in the sorted portion of the array.A hole is created at the top
7
![Page 43: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/43.jpg)
Sorting
43
Percolate down the hole
1615 19
10
15
1710
7
![Page 44: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/44.jpg)
Sorting
44
Fill the hole
1615 19
107
15
17107
![Page 45: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/45.jpg)
Sorting
45
DeleteMax the top element 15
1615 19
7
17
10
7
Store the last heap element (10) in a temporary place.
Move the DeletedMax element (15) to the place where the last heap element was - the current available position in the sorted portion of the array.A hole is created at the top
![Page 46: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/46.jpg)
Sorting
46
Percolate down the hole
1615 19
7
17
10
7
Since 10 is greater than the children of the hole, It has to be inserted in the hole
![Page 47: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/47.jpg)
Sorting
47
Fill the hole
1615 19
7
10
1710 7
![Page 48: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/48.jpg)
Sorting
48
DeleteMax the top element 10
1615 1917
7
Store the last heap element (7) in a temporary place.
Move the DeletedMax element (10) to the place where the last heap element was - the current available position in the sorted portion of the array.A hole is created at the top
10
![Page 49: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/49.jpg)
Sorting
49
Fill the hole
1615 19
7
177 10
The hole has no children and so it has to be filled.
![Page 50: Chapter 7: Sorting Algorithms Insertion Sort. Sorting Algorithms Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort 2](https://reader034.vdocuments.site/reader034/viewer/2022052123/56649eff5503460f94c14a5b/html5/thumbnails/50.jpg)
Sorted array
50
1615 19177 10
7 is the last element from the heap,
so now the array is sorted