Merge Sort

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
7 2 9 4 3 8 6 1  1 2 3 4 6 7 8 9

7 2 9 4  2 4 7 9 3 8 6 1  1 3 8 6

7 2  2 7 9 4  4 9 3 8  3 8 6 1  1 6

77 22 99 44 33 88 66 11

 Execution Example (cont.)
• Recursive call, partition
7 2 9 43 8 6 1  1 2 3 4 6 7 8 9

7 29 4 2 4 7 9 3 8 6 1  1 3 8 6

7 2  2 7 9 4  4 9 3 8  3 8 6 1  1 6

77 22 99 44 33 88 66 11

 Execution Example (cont.)
• Recursive call, partition
7 2 9 43 8 6 1  1 2 3 4 6 7 8 9

7 29 4 2 4 7 9 3 8 6 1  1 3 8 6

722 7 9 4  4 9 3 8  3 8 6 1  1 6

77 22 99 44 33 88 66 11

 Execution Example (cont.)
• Recursive call, base case
7 2 9 43 8 6 1  1 2 3 4 6 7 8 9

7 29 4 2 4 7 9 3 8 6 1  1 3 8 6

722 7 9 4  4 9 3 8  3 8 6 1  1 6

77 22 99 44 33 88 66 11

 Execution Example (cont.)
• Recursive call, base case
7 2 9 43 8 6 1  1 2 3 4 6 7 8 9

7 29 4 2 4 7 9 3 8 6 1  1 3 8 6

722 7 9 4  4 9 3 8  3 8 6 1  1 6

77 22 99 44 33 88 66 11

 Execution Example (cont.)
• Merge
7 2 9 43 8 6 1  1 2 3 4 6 7 8 9

7 29 4 2 4 7 9 3 8 6 1  1 3 8 6

722 7 9 4  4 9 3 8  3 8 6 1  1 6

77 22 99 44 33 88 66 11

 Execution Example (cont.)
• Recursive call, …, base case, merge
7 2 9 43 8 6 1  1 2 3 4 6 7 8 9

7 29 4 2 4 7 9 3 8 6 1  1 3 8 6

722 7 9 4  4 9 3 8  3 8 6 1  1 6

77 22 99 44 33 88 66 11

 Execution Example (cont.)
• Merge
7 2 9 43 8 6 1  1 2 3 4 6 7 8 9

7 29 4 2 4 7 9 3 8 6 1  1 3 8 6

722 7 9 4  4 9 3 8  3 8 6 1  1 6

77 22 99 44 33 88 66 11

 Execution Example (cont.)
• Recursive call, …, merge, merge
7 2 9 43 8 6 1  1 2 3 4 6 7 8 9

7 29 4 2 4 7 9 3 8 6 1  1 3 6 8

722 7 9 4  4 9 3 8  3 8 6 1  1 6

77 22 99 44 33 88 66 11

 Execution Example (cont.)
• Merge
7 2 9 43 8 6 1  1 2 3 4 6 7 8 9

7 29 4 2 4 7 9 3 8 6 1  1 3 6 8

722 7 9 4  4 9 3 8  3 8 6 1  1 6

77 22 99 44 33 88 66 11

Assume We Have a merge Method
void mergeSort ( int A[100], int i, int j)
{
int m;
if ( i < j ){

m = ( i + j )/2; main( )
{
mergeSort (A, i, m); int A[100];
int size;
mergeSort (A, m+1, j); /* read array A and its size */
mergeSort(A[ ], 0, size-1);
merge (A, i, m, j); }
}
 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
 Function merge
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;

while ((k1 <= j1) || (k2 <= j2))

{ Contd..

if (k1 > j1) { else if (k2 > j2)

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

tmpArray[k] = A[k2]; ++k2; } --k;

}
++k;
}
/* Advance indx for writing */
}
 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
 Selection Sort

45312
 Insertion Sort

45312
 Insertion Sort

45312
 Insertion Sort

45312

4 512
 Insertion Sort

45312

4 512

4512
 Insertion Sort

45312

4 512

4512

34512
 Insertion Sort

45312 34512

4 512

4512

34512
 Insertion Sort

45312 34512

4 512 34 52

4512

34512
 Insertion Sort

45312 34512

4 512 34 52

4512 3 452

34512
 Insertion Sort

45312 34512

4 512 34 52

4512 3 452

34512 3452
 Insertion Sort

45312 34512

4 512 34 52

4512 3 452

34512 3452

13452
 Insertion Sort

45312 34512 13452

4 512 34 52

4512 3 452

34512 3452

13452
 Insertion Sort

45312 34512 13452

4 512 34 52 134 5

4512 3 452

34512 3452

13452
 Insertion Sort

45312 34512 13452

4 512 34 52 134 5

4512 3 452 13 45

34512 3452

13452
 Insertion Sort

45312 34512 13452

4 512 34 52 134 5

4512 3 452 13 45

34512 3452 1 345

13452
 Insertion Sort

45312 34512 13452

4 512 34 52 134 5

4512 3 452 13 45

34512 3452 1 345

13452 12345
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;