1. Algorithms
Sorting

2. The Sorting Problem Input: Output:
A sequence of n numbers a1, a2, , an
Output:
A permutation (reordering) a1’, a2’, , an’ of the input sequence such that a1’ ≤ a2’ ≤ · · · ≤ an’

3. Example 53 10 2 62
128 93 28 18 2 10 18 28 53 62 93
128

4. Sorting algorithms Insertion sort Selection sort Bubble sort Heap sort
Merge sort
Quick sort
Bucket sort
Radix sort
O( n2 )
O( n log n )
O( n )

5. Insertion Sort Idea: like sorting a hand of playing cards
Start with an empty left hand and the cards facing down on the table.
Remove one card at a time from the table, and insert it into the correct position in the left hand
compare it with each of the cards already in the hand, from right to left
The cards held in the left hand are sorted
these cards were originally the top cards of the pile on the table

6. Insertion Sort
To insert 12, we need to make room for it by moving first 36 and then 24. 6 10 24 36 12

7. Insertion Sort 6 10 24 36 12

8. Insertion Sort 24 36 10 6 12

9. Insertion Sort 5 2 4 6 1 3 input array
at each iteration, the array is divided in two sub-arrays:
left sub-array
right sub-array
unsorted
sorted

10. Insertion Sort

11. Insertion sort example

12. An Example: Insertion Sort30 10 40 20
i =  j =  key =  A[j] =  A[j+1] =  1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

13. An Example: Insertion Sort30 10 40 20
i = 2 j = 1 key = 10 A[j] = 30 A[j+1] = 10 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

14. An Example: Insertion Sort30 30 40 20
i = 2 j = 1 key = 10 A[j] = 30 A[j+1] = 30 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

15. An Example: Insertion Sort30 30 40 20
i = 2 j = 1 key = 10 A[j] = 30 A[j+1] = 30 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

16. An Example: Insertion Sort30 30 40 20
i = 2 j = 0 key = 10 A[j] =  A[j+1] = 30 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

17. An Example: Insertion Sort30 30 40 20
i = 2 j = 0 key = 10 A[j] =  A[j+1] = 30 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

18. An Example: Insertion Sort10 30 40 20
i = 2 j = 0 key = 10 A[j] =  A[j+1] = 10 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

19. An Example: Insertion Sort10 30 40 20
i = 3 j = 0 key = 10 A[j] =  A[j+1] = 10 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

20. An Example: Insertion Sort10 30 40 20
i = 3 j = 0 key = 40 A[j] =  A[j+1] = 10 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

21. An Example: Insertion Sort10 30 40 20
i = 3 j = 0 key = 40 A[j] =  A[j+1] = 10 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

22. An Example: Insertion Sort10 30 40 20
i = 3 j = 2 key = 40 A[j] = 30 A[j+1] = 40 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

23. An Example: Insertion Sort10 30 40 20
i = 3 j = 2 key = 40 A[j] = 30 A[j+1] = 40 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

24. An Example: Insertion Sort10 30 40 20
i = 3 j = 2 key = 40 A[j] = 30 A[j+1] = 40 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

25. An Example: Insertion Sort10 30 40 20
i = 4 j = 2 key = 40 A[j] = 30 A[j+1] = 40 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

26. An Example: Insertion Sort10 30 40 20
i = 4 j = 2 key = 20 A[j] = 30 A[j+1] = 40 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

27. An Example: Insertion Sort10 30 40 20
i = 4 j = 2 key = 20 A[j] = 30 A[j+1] = 40 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

28. An Example: Insertion Sort10 30 40 20
i = 4 j = 3 key = 20 A[j] = 40 A[j+1] = 20 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

29. An Example: Insertion Sort10 30 40 20
i = 4 j = 3 key = 20 A[j] = 40 A[j+1] = 20 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

30. An Example: Insertion Sort10 30 40 40
i = 4 j = 3 key = 20 A[j] = 40 A[j+1] = 40 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

31. An Example: Insertion Sort10 30 40 40
i = 4 j = 3 key = 20 A[j] = 40 A[j+1] = 40 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

32. An Example: Insertion Sort10 30 40 40
i = 4 j = 3 key = 20 A[j] = 40 A[j+1] = 40 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

33. An Example: Insertion Sort10 30 40 40
i = 4 j = 2 key = 20 A[j] = 30 A[j+1] = 40 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

34. An Example: Insertion Sort10 30 40 40
i = 4 j = 2 key = 20 A[j] = 30 A[j+1] = 40 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

35. An Example: Insertion Sort10 30 30 40
i = 4 j = 2 key = 20 A[j] = 30 A[j+1] = 30 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

36. An Example: Insertion Sort10 30 30 40
i = 4 j = 2 key = 20 A[j] = 30 A[j+1] = 30 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

37. An Example: Insertion Sort10 30 30 40
i = 4 j = 1 key = 20 A[j] = 10 A[j+1] = 30 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

38. An Example: Insertion Sort10 30 30 40
i = 4 j = 1 key = 20 A[j] = 10 A[j+1] = 30 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

39. An Example: Insertion Sort10 20 30 40
i = 4 j = 1 key = 20 A[j] = 10 A[j+1] = 20 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }

40. An Example: Insertion Sort10 20 30 40
i = 4 j = 1 key = 20 A[j] = 10 A[j+1] = 20 1 2 3 4
InsertionSort(A, n) { for i = 2 to n { key = A[i] j = i - 1; while (j > 0) and (A[j] > key) { A[j+1] = A[j] j = j - 1 } A[j+1] = key } }
Done!

41. Example of insertion sort8 2 4 9 3 6 2 8 4 9 3 6 2 4 8 9 3 6 2 4 8 9 3 6 2 3 4 8 9 6 2 3 4 6 8 9
done

42. Analysis of Insertion Sort
INSERTION-SORT(A)
for j ← 2 to n
do key ← A[ j ]
Insert A[ j ] into the sorted sequence A[1 . . j -1]
i ← j - 1
while i > 0 and A[i] > key
do A[i + 1] ← A[i]
i ← i – 1
A[i + 1] ← key
cost times
c n
c2 n-1
0 n-1
c4 n-1 c5 c6 c7
c8 n-1 7
tj: # of times the while statement is executed at iteration j

43. Best Case Analysis The array is already sorted
tj = 1
T(n) = c1n + c2(n -1) + c4(n -1) + c5(n -1) + c8(n-1) = (c1 + c2 + c4 + c5 + c8)n + (c2 + c4 + c5 + c8)
= an + b = (n)
“while i > 0 and A[i] > key”

44. Worst Case Analysis The array is in reverse sorted order
Always A[i] > key in while loop test
Have to compare key with all elements to the left of the j-th position  compare with j-1 elements  tj = j
a quadratic function of n
T(n) = (n2) order of growth in n2
“while i > 0 and A[i] > key”
using
we have:

45. Bubble Sort Idea: Easier to implement, but slower than Insertion sort
Repeatedly pass through the array
Swaps adjacent elements that are out of order
Easier to implement, but slower than Insertion sort i 1 2 3 n 1 3 2 9 6 4 8 j

46. Example 1 3 2 9 6 4 8
i = 1 j 3 2 9 6 4 8 1
i = 2 j 3 1 2 9 6 4 8
i = 1 j 3 9 6 4 8 2 1
i = 3 j 3 2 1 9 6 4 8
i = 1 j 9 6 4 8 3 2 1
i = 4 j 3 2 9 1 6 4 8
i = 1 j 9 6 8 4 3 2 1
i = 5 j 3 2 9 6 1 4 8
i = 1 j 9 8 6 4 3 2 1
i = 6 j 3 2 9 6 4 1 8
i = 1 j 9 8 6 4 3 2 1
i = 7 j 3 2 9 6 4 8 1
i = 1 j

47. Bubble Sort Alg.: BUBBLESORT(A) for i  1 to length[A]
do for j  length[A] downto i + 1
do if A[j] < A[j -1]
then exchange A[j]  A[j-1] i 1 3 2 9 6 4 8
i = 1 j

48. Bubble-Sort Running Time
Alg.: BUBBLESORT(A)
for i  1 to length[A]
do for j  length[A] downto i + 1
do if A[j] < A[j -1]
then exchange A[j]  A[j-1] c1 c2 c3
Comparisons:  n2/2 c4
Exchanges:  n2/2
T(n) =
c1(n+1) + c2 c3 c4
= (n) +
(c2 + c2 + c4)
Thus,T(n) = (n2)

49. Selection Sort Idea: Disadvantage:
Find the smallest element in the array
Exchange it with the element in the first position
Find the second smallest element and exchange it with the element in the second position
Continue until the array is sorted
Disadvantage:
Running time depends only slightly on the amount of order in the file

50. Example 1 3 2 9 6 4 8 8 6 9 4 3 2 1 8 3 2 9 6 4 1 8 9 6 4 3 2 1 8 3 4 9 6 2 1 9 8 6 4 3 2 1 8 6 4 9 3 2 1 9 8 6 4 3 2 1

51. Selection Sort Alg.: SELECTION-SORT(A) n ← length[A]
for j ← 1 to n - 1
do smallest ← j
for i ← j + 1 to n
do if A[i] < A[smallest]
then smallest ← i
exchange A[j] ↔ A[smallest] 1 3 2 9 6 4 8

52. Analysis of Selection Sort
Alg.: SELECTION-SORT(A)
n ← length[A]
for j ← 1 to n - 1
do smallest ← j
for i ← j + 1 to n
do if A[i] < A[smallest]
then smallest ← i
exchange A[j] ↔ A[smallest]
cost times c
c2 n
c3 n-1 c4 c5 c6
c7 n-1
n2/2
comparisons n
exchanges

53. Time complexity summary
Algorithm
Best
case
Worst
Insertion sort
O( n )
O(n2 )
Selection sort
Bubble sort