![Bubble Sort
Algorithm
for i 1 to n-1 do
for j 1 to n-i do
if (A[j+1] < A[j]) swap A[j] and A[j+1] ;
}
}
Analysis:
In general, if the list has n elements, we will have to do
(n-1) + (n-2) …. + 2 +1 = (n-1) n / 2 comparisons.
=O(n^2)
12](https://image.slidesharecdn.com/ds3-sorting-180827163439/85/Data-Structure-and-Algorithms-Sorting-12-320.jpg)
![Insertion Sort
INSERTION_SORT (A, N)
1.Set A[0] = -∞.
2.Repeat Step 3 to 5 for K = 2, 3, …, N:
3. Set TEMP = A[K] and PTR = K – 1.
4. Repeat while TEMP < A[PTR]:
(a) Set A[PTR+1] = A[PTR]
(b) Set PTR = PTR – 1.
[End of Loop.]
5. Set A[PTR+1] = TEMP.
[End of Loop 2.]
6.Return.](https://image.slidesharecdn.com/ds3-sorting-180827163439/85/Data-Structure-and-Algorithms-Sorting-13-320.jpg)
![Selection Sort
This algorithm sorts an array A with N elements.
SELECTION(A, N)
1.Repeat steps 2 and 3 for k=1 to N-1:
2. Call MIN(A, K, N, LOC).
3. [Interchange A[k] and A[LOC]]
Set Temp:= A[k], A[k]:= A[LOC] and A[LOC]:=Temp.
[End of step 1 Loop.]
1.Exit.
MIN(A, K, N, LOC).
1.Set MIN := A[K] and LOC:= K.
2.Repeat for j=k+1 to N:
If Min>A[j], then: Set Min:= A[j] and LOC:=J.
[End of if structure]
3.Return.](https://image.slidesharecdn.com/ds3-sorting-180827163439/85/Data-Structure-and-Algorithms-Sorting-16-320.jpg)
Data Structure and Algorithms Sorting
- 2. Sorting Algorithm Sorting takes an unordered collection and makes it an ordered one. 2 512354277 101 5 12 35 42 77 101 1 2 3 4 5 6 1 2 3 4 5 6
- 3. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pair- wise comparisons and swapping 3 512354277 101 1 2 3 4 5 6
- 4. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pair- wise comparisons and swapping 4 512354277 101Swap42 77 1 2 3 4 5 6
- 5. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pair- wise comparisons and swapping 5 512357742 101Swap35 77 1 2 3 4 5 6
- 6. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pair- wise comparisons and swapping 6 512773542 101Swap12 77 1 2 3 4 5 6
- 7. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pair- wise comparisons and swapping 7 577123542 101 No need to swap 1 2 3 4 5 6
- 8. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pair- wise comparisons and swapping 8 577123542 101 Swap5 101 1 2 3 4 5 6
- 9. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pair- wise comparisons and swapping 9 77123542 5 101 Largest value correctly placed 1 2 3 4 5 6
- 10. Repeat “Bubble Up” How Many Times? If we have N elements… And if each time we bubble an element, we place it in its correct location… Then we repeat the “bubble up” process N – 1 times. This guarantees we’ll correctly place all N elements. 10
- 11. “Bubbling” All the Elements 11 77123542 5 101 5421235 77 101 4253512 77 101 4235512 77 101 4235125 77 101 N-1 1 2 3 4 5 6
- 12. Bubble Sort Algorithm for i 1 to n-1 do for j 1 to n-i do if (A[j+1] < A[j]) swap A[j] and A[j+1] ; } } Analysis: In general, if the list has n elements, we will have to do (n-1) + (n-2) …. + 2 +1 = (n-1) n / 2 comparisons. =O(n^2) 12
- 13. Insertion Sort INSERTION_SORT (A, N) 1.Set A[0] = -∞. 2.Repeat Step 3 to 5 for K = 2, 3, …, N: 3. Set TEMP = A[K] and PTR = K – 1. 4. Repeat while TEMP < A[PTR]: (a) Set A[PTR+1] = A[PTR] (b) Set PTR = PTR – 1. [End of Loop.] 5. Set A[PTR+1] = TEMP. [End of Loop 2.] 6.Return.
- 14. Insertion Sort Example Sort: 34 8 64 51 32 21 34 8 64 51 32 21 The algorithm sees that 8 is smaller than 34 so it swaps. 8 34 64 51 32 21 51 is smaller than 64, so they swap. 8 34 51 64 32 21 8 34 51 64 32 21 (from previous slide) The algorithm sees 32 as another smaller number and moves it to its appropriate location between 8 and 34. 8 32 34 51 64 21 The algorithm sees 21 as another smaller number and moves into between 8 and 32. Final sorted numbers: 8 21 32 34 51 64
- 15. Insertion Sort Complexity This Sorting algorithm is frequently used when n is very small. Worst case occurs when array is in reverse order. The inner loop must use K – 1 comparisons. f(n) = 1 + 2 + 3 + ….+ (n – 1) = n(n – 1)/2 = O(n2 ) In average case, there will be approximately (K – 1)/2 comparisons in the inner loop. f(n) = (1 + 2 + 3 + ….+ (n – 1))/2 = n(n – 1)/4 = O(n2 )
- 16. Selection Sort This algorithm sorts an array A with N elements. SELECTION(A, N) 1.Repeat steps 2 and 3 for k=1 to N-1: 2. Call MIN(A, K, N, LOC). 3. [Interchange A[k] and A[LOC]] Set Temp:= A[k], A[k]:= A[LOC] and A[LOC]:=Temp. [End of step 1 Loop.] 1.Exit. MIN(A, K, N, LOC). 1.Set MIN := A[K] and LOC:= K. 2.Repeat for j=k+1 to N: If Min>A[j], then: Set Min:= A[j] and LOC:=J. [End of if structure] 3.Return.
- 18. Selection Sort Complexity The number f(n) of comparisons in selection sort algorithm is independent of original order of elements. There are n-1 comparisons during pass 1 to find the smallest element, n-2 comparisons during pass 2 to find the second smallest element, and so on. Accordingly, f (n) = (n-1)+(n-2)+-----+2+1 = n(n-1)/2 = O(n2 ) The f (n) holds the same value O(n2 ) both for worst case and average case.
- 19. Comparing the Algorithms Best Average Worst Case Case Case Bubble Sort O(n) O(n2 ) O(n2 ) Insertion Sort O(n) O(n2 ) O(n2 ) Selection Sort O(n2 ) O(n2 ) O(n2 )
- 20. Thank You