Merge Sort: SCJ2013 Data Structure & Algorithms

SCJ2013 Data Structure & Algorithms
Merge Sort
Nor Bahiah Hj Ahmad & Dayang

Norhayati A. Jawawi
Merge Sort
Merge Sort applies divide and conquer strategy.
Three main steps in Merge Sort algorithm:

Divide an array into halves until only one piece left
Sort each half
Merge the sorted halves into one sorted array
A recursive sorting algorithm

Performance is independent of the initial order of
the array items
Merge Sort Operation
Divide
Sort
and
merge
Merge Sort Implementation
MergeSort() function
A Recursive function that divide the array into pieces until

each piece contain only one item.
The small pieces are merged into larger sorted pieces until
one sorted array is achieved.
mergeSort() function
void mergeSort(DataType theArray[],int first,int last)
{ if (first < last)
{ // sort each half
int mid = (first + last)/2; divide the
// index of midpoint array into
// sort left half theArray[first..mid] pieces
mergesort(theArray, first, mid);
// sort right half theArray[mid+1..last]
mergesort(theArray, mid+1, last);
// merge the two halves
merge(theArray, first, mid, last);
} // end if small pieces
are merged
} // end mergesort
mergeSort [38 16 27 39 12 27]
mergeSort(theArray,0,5);
mergeSort(theArray,0,2); mergeSort(theArray,3,5);
merge(theArray,0,2,5);
A mergesort of an array of six integers

Merge Sort Implementation
Merge() function
Compares an item into one half of the array with item in

the other half of the array and
Moves the smaller item into temporary array.
Then, the remaining items are simply moved to the
temporary array.
The temporary array is copied back into the original array.
merge() function
const int MAX_SIZE = maxNmbrItemInArry;
void merge(DataType theArray[],
int first, int mid, int last)
{ DataType tempArray[MAX_SIZE]; // temp array
int first1 = first; // first subarray begin
int last1 = mid; // end of first subarray Duplicate
int first2 = mid + 1; // secnd subarry begin the positions
int last2 = last; // end of secnd subarry
// while both subarrays are not empty,

// copy the smaller item into the
// temporary array
int index = first1;
// next available location in tempArray
for (; (first1 <= last1) && (first2 <=
last2); ++index) Moves the smaller
{if (theArray[first1] < theArray[first2]) item into
{ tempArray[index] = theArray[first1]; temporary array
++first1; }
else
{ tempArray[index] = theArray[first2];
++first2; }
} // end if
merge() function
for (; first1 <= last1;
++first1, ++index)
tempArray[index] =
theArray[first1];
// finish off the second
// subarray, if necessary move the remaining
items to the temporary array
for (; first2 <= last2;
++first2, ++index)
tempArray[index] =
theArray[first2];
// copy the result back

// into the original
// array
for (index = first; The temporary array is copied
index <= last; ++index) back into the original array
theArray[index] =
tempArray[index];
} // end merge function
Merge Sort Operation
The array : 38 16 27 39 12 27
Moves the smaller item into

temporary array
16 27 38 12 27 39
Move the remaining

items to the temporary
array
Temporary array
tempArray : 12 16 27 27 38 39
The temporary array is copied back

into the original array
The array : 12 16 27 27 38 39
mergeSort [38 16 27 39 12 27]
1. mergeSort(theArray,0,5);
2. mergeSort(theArray,0,2); 9. mergeSort(theArray,3,5);


6. merge(theArray,1,1); 13. merge(theArray,3,4);
8. merge(theArray,1,1); 15. merge(theArray,3,4);
16. merge(theArray,0,5);
[email protected]
mergeSort [38 16 27 39 12 27]
T
Unsorted data [38 16 27 39 12 27 ]
h
e Content of divided sublist with first=0 & last=5 [38 16 27 39 12 27 ]
Content of divided sublist with first=0 & last=2 [38 16 27 ]
E Content of divided sublist with first=0 & last=1 [38 16 ]
x Content of divided sublist with first=0 & last=0 [38 ]
e Content of divided sublist with first=1 & last=1 [16 ]
c Content of merged list with first=0 & last=1 [16 38 ]
u Content of divided sublist with first=2 & last=2 [27 ]
Content of merged list with first=0 & last=2 [16 27 38 ]
t
Content of divided sublist with first=3 & last=5 [39 12 27 ]
i Content of divided sublist with first=3 & last=4 [39 12 ]
o Content of divided sublist with first=3 & last=3 [39 ]
n Content of divided sublist with first=4 & last=4 [12 ]
Content of merged list with first=3 & last=4 [12 39 ]
R Content of divided sublist with first=5 & last=5 [27 ]
e Content of merged list with first=3 & last=5 [12 27 39 ]
s Content of merged list with first=0 & last=5 [12 16 27 27 38 39 ]
u
Sorted data [12 16 27 27 38 39 ]
l Press any key to continue . . .
t
Merge Sort Analysis
The list is always divided into two balanced list (or almost
balanced for odd size of list)
The number of calls to repeatedly divide the list until there is
one item left in the list is:
Assuming that the left segment and the right segment of the
list have the equal size (or almost equal size), then x lg n .
The number of iteration is approximately n lg n
Merge Sort Analysis
The same number of
repetition is needed
to sort and merge the
list.
Thus, as a whole the
number of steps
needed to sort data
using merge sort is 2n
lg n, which is
O(n lg n).
Mergesort
Analysis
Worst case: O(n * log2n)
Average case: O(n * log2n)
Performance is independent of the initial order of the array items
Advantage
Mergesort is an extremely fast algorithm
Disadvantage
Mergesort requires a second array (temporary array) as
large as the original array
References
1. Frank M. Carano, Janet J Prichard. Data
Abstraction and problem solving with C++
Walls and Mirrors. 5th edition (2007).
Addision Wesley.
2. Nor Bahiah et al. Struktur data & algoritma
menggunakan C++. Penerbit UTM, 2005.
12/10/2011 16

Merge Sort: SCJ2013 Data Structure & Algorithms

Uploaded by

Copyright:

Available Formats

Merge Sort: SCJ2013 Data Structure & Algorithms

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Merge Sort: SCJ2013 Data Structure & Algorithms

Uploaded by

Copyright:

Available Formats

SCJ2013 Data Structure & Algorithms

Nor Bahiah Hj Ahmad & Dayang

Three main steps in Merge Sort algorithm:

A recursive sorting algorithm

A Recursive function that divide the array into pieces until

A mergesort of an array of six integers

Compares an item into one half of the array with item in

// while both subarrays are not empty,

// copy the result back

Moves the smaller item into

Move the remaining

The temporary array is copied back

3. mergeSort(theArray,0,1); 10. mergeSort(theArray,3,4);

4. mergeSort(theArray,0,0); 11. mergeSort(theArray,3,3);

6. merge(theArray,1,1); 13. merge(theArray,3,4);

8. merge(theArray,1,1); 15. merge(theArray,3,4);

You might also like