Merge Sort

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

Execution Example Partition       1 67  72  29  94  43  38  86  61  

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

Execution Example (cont.) Recursive call, partition 7 2  9 4    2      72  29  94  43  38  86  61   

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

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

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

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

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

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

Execution Example (cont.) Merge 7 2  9 4    2      77  72  22  29  94  43  33  38  88  86  66  61  11   

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); }

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

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..

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..

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

Selection Sort

Insertion Sort

Insertion Sort

Insertion Sort

Insertion Sort

Insertion Sort

Insertion Sort

Insertion Sort

Insertion Sort

Insertion Sort

Insertion Sort

Insertion Sort

Insertion Sort

Insertion Sort

Insertion Sort

Insertion Sort

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; }