Software Technology-1

Lecture 8

Advanced sorting - Merge Sort

Sri Lanka Institute of Information Technology 1

Merge Sort

Much more efficient than Bubble Sort and

Selection Sort
Involves Recursion
Requires an additional array in memory

2
Merge Sort - Demo

10 5 8 2 12 6 3 4

3
Merge Sort - Demo

10 5 8 2 12 6 3 4

10 5 8 2 12 6 3 4

4
Merge Sort - Demo

10 5 8 2 12 6 3 4

10 5 8 2 12 6 3 4

10 5 8 2 12 6 3 4

5
Merge Sort - Demo

10 5 8 2 12 6 3 4

10 5 8 2 12 6 3 4

10 5 8 2 12 6 3 4

10 5 8 2 12 6 3 4

6
Merge Sort - Demo

10 5 8 2 12 6 3 4

7
Merge Sort - Demo

5 10

10 5 8 2 12 6 3 4

8
Merge Sort - Demo

5 10 2 8

10 5 8 2 12 6 3 4

9
Merge Sort - Demo

5 10 2 8 6 12

10 5 8 2 12 6 3 4

10
Merge Sort - Demo

5 10 2 8 6 12 3 4

10 5 8 2 12 6 3 4

11
Merge Sort - Demo

2 5 8 10

5 10 2 8 6 12 3 4

10 5 8 2 12 6 3 4

12
Merge Sort - Demo

2 5 8 10 3 4 6 12

5 10 2 8 6 12 3 4

10 5 8 2 12 6 3 4

13
Merge Sort - Demo

2 3 4 5 6 8 10 12

2 5 8 10 3 4 6 12

5 10 2 8 6 12 3 4

10 5 8 2 12 6 3 4

14
Merge Sort - Demo

2 3 4 5 6 8 10 12

15
Merge Sort

Code

16
Merge Sort - Code

10 5 8 2 12 6 3 4
0 nElems-1

lowerBound upperBound

17
Merge Sort - Code

10 5 8 2 12 6 3 4
0 1 2 3 4 5 6 7

lowerBound upperBound

mid = (lowerBound+upperBound) / 2

18
Merge Sort - Code

10 5 8 2 12 6 3 4
0 1 2 3 4 5 6 7

10 5 8 2
0 1 2 3

19
Merge Sort - Code

10 5 8 2 12 6 3 4
0 1 2 3 4 5 6 7

10 5 8 2 12 6 3 4
0 1 2 3
4 5 6 7

2 5 8 10 3 4 6 12
0 1 2 3 4 5 6 7

20
 Merge Sort - Code

void mergeSort(int nElems)

{
double *workSpace = new double [nElems];
recMergeSort(workSpace, 0, nElems-1);
delete [] workspace;
}

void recMergeSort(double workSpace[], int lowerBounds, int upperBound)

{
if (lowerBound == upperBound)
return;
else
{
int mid = (lowerBound + upperBound) / 2;
recMergeSort(workSpace, lowerBound, mid);
recMergeSort(workspace, mid+1, upperBound);
merge(workSpace, lowerBound, mid+1, upperBound);

} 21
}
Merge Sort - Code

workSpace

theArray 2 5 8 10 3 9 12 13

22
Merge Sort - Code

2 5 8 10 3 9 12 13

lowPtr highPtr

23
Merge Sort - Code

2 5 8 10 3 9 12 13

lowPtr highPtr

24
Merge Sort - Code

2 3

2 5 8 10 3 9 12 13

lowPtr highPtr

25
Merge Sort - Code

2 3 5

2 5 8 10 3 9 12 13

lowPtr highPtr

26
Merge Sort - Code

2 3 5 8

2 5 8 10 3 9 12 13

lowPtr highPtr

27
Merge Sort - Code

2 3 5 8 9

2 5 8 10 3 9 12 13

lowPtr highPtr

28
Merge Sort - Code

2 3 5 8 9 10

2 5 8 10 3 9 12 13

lowPtr highPtr

29
Merge Sort - Code

2 3 5 8 9 10 12

2 5 8 10 3 9 12 13

lowPtr highPtr

30
Merge Sort - Code

2 3 5 8 9 10 12 13

2 5 8 10 3 9 12 13

lowPtr highPtr

31
 The merge(...) method
void merge(double workSpace[],int lowPtr,int
hightPtr,int upperBound){

32
Merge Sort - Code

2 5 8 10 3 9 12 13

lowPtr mid highPtr upper

bound
33
 Merge Sort - Code

void mergeSort(int nElems)

{
double *workSpace = new double [nElems];
recMergeSort(workSpace, 0, nElems-1);
delete [] workSpace;
}

void recMergeSort(double workSpace[], int lowerBounds, int upperBound)

{
if (lowerBound == upperBound)
return;
else
{
int mid = (lowerBound + upperBound) / 2;
recMergeSort(workSpace, lowerBound, mid);
recMergeSort(workspace, mid+1, upperBound);
merge(workSpace, lowerBound, mid+1, upperBound);

} 34
}
void merge(double workSpace[],int lowPtr,int hightPtr,int upperBound){
int j = 0;
int lowerBound = lowPtr;
int mid = highPtr-1;

int n = upperBound-lowerBound+1;

while (lowPtr <= mid && highPtr <= upperBound)

if (theArray[lowPtr] < theArray[highPtr])
workSpace[j++] = theArray[lowPtr++];
else
workSpace[j++] = theArray[highPtr++];

while (lowPtr <= mid)

workSpace[j++] = theArray[lowPtr++];

while (highPtr <= upperBound)

workSpace[j++] = theArray[highPtr++];

for (j=0; j<n; j+++)

theArray[lowerBound+j] = workSpace[j];
}
35
 10 5 8 2 12 6 3 4

10 5 8 2

10 5 8 2

10 5

5 10 8 2

2 8

2 5 8 10 12 6 3 4

12 6 3 4

12 6

6 12 3 4

3 4

3 4 6 12
36
2 3 4 5 6 8 10 12
Efficiency of Merge Sort

O (N*logN)

37