1. Merge Sort

2. In plain English: if the size of the array > 1, split the array into two halves, and recursively sort both halves; when the sorts return, merge the two halves Pseudocode for function mergesort: if array size equals 1 return copy first half into leftArray copy second half into rightArray sort (leftArray) sort (rightArray) merge leftArray with rightArray

3. Execution Example Partition 7 2 9 4  2 4 7 93 8 6 1  1 3 8 67 2  2 79 4  4 93 8  3 86 1  1 67  72  29  94  43  38  86  61  1 7 2 9 4 3 8 6 1  1 2 3 4 6 7 8 9

4. Execution Example (cont.) Recursive call, partition 7 2  9 4  2 4 7 9 3 8 6 1  1 3 8 6 7 2  2 79 4  4 93 8  3 86 1  1 67  72  29  94  43  38  86  61  1 7 2 9 4  3 8 6 1  1 2 3 4 6 7 8 9

5. Execution Example (cont.) Recursive call, partition 7 2  9 4  2 4 7 93 8 6 1  1 3 8 6 7  2  2 7 9 4  4 93 8  3 86 1  1 6 7  72  29  94  43  38  86  61  1 7 2 9 4  3 8 6 1  1 2 3 4 6 7 8 9

6. Execution Example (cont.) Recursive call, base case 7 2  9 4  2 4 7 93 8 6 1  1 3 8 6 7  2  2 79 4  4 93 8  3 86 1  1 6 7  77  7 2  29  94  43  38  86  61  1 7 2 9 4  3 8 6 1  1 2 3 4 6 7 8 9

7. Execution Example (cont.) Recursive call, base case 7 2  9 4  2 4 7 93 8 6 1  1 3 8 6 7  2  2 79 4  4 93 8  3 86 1  1 6 7  77  72  22  29  94  43  38  86  61  1 7 2 9 4  3 8 6 1  1 2 3 4 6 7 8 9

8. Execution Example (cont.) Merge 7 2  9 4  2 4 7 93 8 6 1  1 3 8 6 7  2  2 7 9 4  4 93 8  3 86 1  1 6 7  77  72  22  29  94  43  38  86  61  1 7 2 9 4  3 8 6 1  1 2 3 4 6 7 8 9

9. Execution Example (cont.) Recursive call, …, base case, merge 7 2  9 4  2 4 7 93 8 6 1  1 3 8 6 7  2  2 7 9 4  4 9 3 8  3 86 1  1 6 7  77  72  22  23  38  86  61  1 7 2 9 4  3 8 6 1  1 2 3 4 6 7 8 9 9  94  4

10. Execution Example (cont.) Merge 7 2  9 4  2 4 7 9 3 8 6 1  1 3 8 6 7  2  2 79 4  4 93 8  3 86 1  1 6 7  77  72  22  29  94  43  38  86  61  1 7 2 9 4  3 8 6 1  1 2 3 4 6 7 8 9

11. Execution Example (cont.) Recursive call, …, merge, merge 7 2  9 4  2 4 7 9 3 8 6 1  1 3 6 8 7  2  2 79 4  4 93 8  3 86 1  1 6 7  77  72  22  29  94  43  33  38  88  86  66  61  11  1 7 2 9 4  3 8 6 1  1 2 3 4 6 7 8 9

12. Execution Example (cont.) Merge 7 2  9 4  2 4 7 93 8 6 1  1 3 6 8 7  2  2 79 4  4 93 8  3 86 1  1 6 7  77  72  22  29  94  43  33  38  88  86  66  61  11  1 7 2 9 4  3 8 6 1  1 2 3 4 6 7 8 9

13. Assume We Have a merge Method void mergeSort ( int A[100], int i, int j) { int m; if ( i < j ){ m = ( i + j )/2; mergeSort (A, i, m); mergeSort (A, m+1, j); merge (A, i, m, j); } main( ) { int A[100]; int size; /* read array A and its size */ mergeSort(A[ ], 0, size-1); }

14. Merge Method Merge algorithm in plain English: while left & right arrays still have elements, copy the lower element from either into the merged array; when either left or right array is exhausted, copy the remainder of the other array into the merged array In pseudocode: while neither array exhausted if element of left array < element of right array copy left element into merged array & increment index else copy right element into merged array & increment index copy balance of unexhausted array into merged array

15. void merge ( int i1, int j1, int j2 ) { int i2, k1, k2, k; int tmpArray[100]; i2 = j1 + 1; k1 = i1; k2 = i2; k = 0; Function merge while ((k1 <= j1) || (k2 <= j2)) { if (k1 > j1) { /* Left half is exhausted */ /* Copy from the right half */ tmpArray [k] = A[k2]; ++k2; } else if (k2 > j2) { /*Right half is exhausted*/ /* Copy from the left half */ tmpArray [k] = A[k1]; ++k1; } Contd..

16. else if (A[k1] < A[k2]) { /* Left indx has a smaller value */ /* Copy from the left half */ tmpArray[k] = A[k1]; ++k1; } else { /* Right indx has a smaller value */ /* Copy from the right half */ tmpArray[k] = A[k2]; ++k2; } ++k; /* Advance indx for writing */ } Contd… /* Copy temporary array back to the original array */ --k; /* has size of tempArray */ while (k >= 0) { A[i1+k] = tmpArray[k]; --k; } Contd..

17. Insertion Sort In plain English: for each element starting with the second, “pull” the element, then look at all earlier elements and shift larger ones to the right, then insert the element In pseudocode: for each element from second to last save the element for each earlier element that is larger shift it right insert current element

18. Selection Sort 4 5 3 1 2

19. Insertion Sort 4 5 3 1 2

20. Insertion Sort 4 5 3 1 2

21. Insertion Sort 4 5 3 1 2 4 5 1 2

22. Insertion Sort 4 5 3 1 2 4 5 1 2

23. Insertion Sort 4 5 3 1 2 4 5 1 2 3 4 5 1 2

24. Insertion Sort 4 5 3 1 2 4 5 1 2 3 4 5 1 2

25. Insertion Sort 4 5 3 1 2 4 5 1 2 3 4 5 1 2 3 4 5 2

26. Insertion Sort 4 5 3 1 2 4 5 1 2 3 4 5 1 2 3 4 5 2

27. Insertion Sort 4 5 3 1 2 4 5 1 2 3 4 5 1 2 3 4 5 2

28. Insertion Sort 4 5 3 1 2 4 5 1 2 3 4 5 1 2 3 4 5 2 1 3 4 5 2

29. Insertion Sort 4 5 3 1 2 4 5 1 2 3 4 5 1 2 3 4 5 2 1 3 4 5 2

30. Insertion Sort 4 5 3 1 2 4 5 1 2 3 4 5 1 2 3 4 5 2 1 3 4 5 2 1 3 4 5

31. Insertion Sort 4 5 3 1 2 4 5 1 2 3 4 5 1 2 3 4 5 2 1 3 4 5 2 1 3 4 5

32. Insertion Sort 4 5 3 1 2 4 5 1 2 3 4 5 1 2 3 4 5 2 1 3 4 5 2 1 3 4 5

33. Insertion Sort 4 5 3 1 2 4 5 1 2 3 4 5 1 2 3 4 5 2 1 3 4 5 2 1 3 4 5 1 2 3 4 5

34. for (i=1; i<n; ++i) { /* Consider A[i] */ /* Search for the correct insertion location of A[i] */ t = A[i]; /* Store A[i] in a temporary variable */ j = 0; /* Initialize search location */ while (t > A[j]) ++j; /* Skip smaller entries */ /* Here j holds the desired insertion location */ /* Shift forward the remaining entries each by one location */ for (k=i-1; k>=j; --k) A[k+1] = A[k]; /* Finally insert the old A[i] at the j-th location */ A[j] = t; }