Computer notes - Mergesort

Class No.39

Data Structures

http://ecomputernotes.com

http://ecomputernotes.com/



Divide and Conquer

What if we split the list into two parts?

10 12 8 4 2 11 7 510 12 8 4 2 11 7 5



Divide and Conquer

Sort the two parts:

10 12 8 4 2 11 7 54 8 10 12 2 5 7 11



Divide and Conquer

Then merge the two parts together:

4 8 10 12 2 5 7 112 4 5 7 8 10 11 12



Analysis

To sort the halves (n/2)2+(n/2)2

To merge the two halves n So, for n=100, divide and conquer

takes:= (100/2)2 + (100/2)2 + 100= 2500 + 2500 + 100 = 5100 (n2 = 10,000)



Divide and Conquer

Why not divide the halves in half? The quarters in half? And so on . . . When should we stop?

At n = 1



SearchSearch

Divide and Conquer

SearchSearch

SearchSearch

Recall: Binary Search



SortSort

Divide and Conquer

SortSort SortSort

SortSort SortSort SortSort SortSort



Divide and Conquer

CombineCombine

CombineCombine CombineCombine



Mergesort

Mergesort is a divide and conquer algorithm that does exactly that.

It splits the list in half Mergesorts the two halves Then merges the two sorted halves

together Mergesort can be implemented

recursively



Mergesort

The mergesort algorithm involves three steps:• If the number of items to sort is 0 or 1,

return• Recursively sort the first and second

halves separately• Merge the two sorted halves into a

sorted group



Merging: animation

4 8 10 12 2 5 7 11

2



Merging: animation

4 8 10 12 2 5 7 11

2 4



Merging: animation

4 8 10 12 2 5 7 11

2 4 5



Merging

4 8 10 12 2 5 7 11

2 4 5 7



Mergesort

8 12 11 2 7 5410

Split the list in half.

8 12410

Mergesort the left half.

Split the list in half. Mergesort the left half.

410

Split the list in half. Mergesort the left half.

10

Mergesort the right.

4http://ecomputernotes.com


Mergesort

8 12 11 2 7 5410

8 12410

410

Mergesort the right half.

Merge the two halves.

104 8 12

128


88 12



Mergesort

8 12 11 2 7 5410

8 12410


410

Mergesort the right half. Merge the two halves.

104 8 12

10 1284

104 8 12



Mergesort

10 12 11 2 7 584


11 2 7 5

11 2

11 2



Mergesort

10 12 11 2 7 584


11 2 7 5

11 22 11

2 11



Mergesort

10 12 11 2 7 584


11 2 7 52 11

75

7 5



Mergesort

10 12 11 2 7 584


11 2 572 11



Mergesort

10 12 2 5 7 1184




Mergesort

5 7 8 10 11 1242




void mergeSort(float array[], int size){ int* tmpArrayPtr = new int[size];

if (tmpArrayPtr != NULL) mergeSortRec(array, size, tmpArrayPtr); else { cout << “Not enough memory to sort list.\n”); return; }

delete [] tmpArrayPtr;}

Mergesort



void mergeSortRec(int array[],int size,int tmp[]){ int i; int mid = size/2; if (size > 1){ mergeSortRec(array, mid, tmp); mergeSortRec(array+mid, size-mid, tmp);

mergeArrays(array, mid, array+mid, size-mid, tmp);

for (i = 0; i < size; i++) array[i] = tmp[i]; }}

Mergesort



3 5 15 28 30 6 10 14 22 43 50a:a: b:b:

aSize: 5aSize: 5 bSize: 6bSize: 6

mergeArrays

tmp:tmp:



mergeArrays

5 15 28 30 10 14 22 43 50a:a: b:b:

tmp:tmp:

i=0i=0

k=0k=0

j=0j=0

3 6



mergeArrays

5 15 28 30 10 14 22 43 50a:a: b:b:

tmp:tmp:

i=0i=0

k=0k=0

3

j=0j=0

3 6



mergeArrays

3 15 28 30 10 14 22 43 50a:a: b:b:

tmp:tmp:

i=1i=1 j=0j=0

k=1k=1

3 5

5 6



mergeArrays

3 5 28 30 10 14 22 43 50a:a: b:b:

3 5tmp:tmp:

i=2i=2 j=0j=0

k=2k=2

6

15 6



mergeArrays

3 5 28 30 6 14 22 43 50a:a: b:b:

3 5 6tmp:tmp:

i=2i=2 j=1j=1

k=3k=3

15 10

10



10

mergeArrays

3 5 28 30 6 22 43 50a:a: b:b:

3 5 6tmp:tmp:

i=2i=2 j=2j=2

k=4k=4

15 10 14

14



1410

mergeArrays

3 5 28 30 6 14 43 50a:a: b:b:

3 5 6tmp:tmp:

i=2i=2 j=3j=3

k=5k=5

15 10 22

15



1410

mergeArrays

3 5 30 6 14 43 50a:a: b:b:

3 5 6tmp:tmp:

i=3i=3 j=3j=3

k=6k=6

15 10 22

2215

28



1410

mergeArrays

3 5 30 6 14 50a:a: b:b:

3 5 6tmp:tmp:

i=3i=3 j=4j=4

k=7k=7

15 10 22

2815

28 43

22



1410

mergeArrays

3 5 6 14 50a:a: b:b:

3 5 6tmp:tmp:

i=4i=4 j=4j=4

k=8k=8

15 10 22

3015

28 43

22

30

28



1410

mergeArrays

3 5 6 14 50a:a: b:b:

3 5 6 30tmp:tmp:

i=5i=5 j=4j=4

k=9k=9

15 10 22

15

28 43

22

30

28 43 50

Done.



Merge Sort and Linked Lists

Sort Sort

Merge



Mergesort AnalysisMerging the two lists of size n/2:

O(n)

Merging the four lists of size n/4:

O(n)...

Merging the n lists of size 1:

O(n)

O (lg n)times

Mergesort is O(n lg n) Space? The other sorts we have looked at (insertion, selection)

are in-place (only require a constant amount of extra space)

Mergesort requires O(n) extra space for merging

Mergesort Analysis

Mergesort is O(n lg n) Space? The other sorts we have looked at

(insertion, selection) are in-place (only require a constant amount of extra space)

Mergesort requires O(n) extra space for merging


Quicksort

Quicksort is another divide and conquer algorithm

Quicksort is based on the idea of partitioning (splitting) the list around a pivot or split value


Quicksort

First the list is partitioned around a pivot value. Pivot can be chosen from the beginning, end or middle of list):

8 32 11 754 10124 5

5

pivot value


Quicksort

The pivot is swapped to the last position and the remaining elements are compared starting at theends.

8 3 2 11 7 54 10124 5

low high

5

pivot value


Quicksort

Then the low index moves right until it is at an element that is larger than the pivot value (i.e., it is on the wrong side)

8 6 2 11 7 510124 6

low high

5

pivot value

312


Quicksort

Then the high index moves left until it is at an element that is smaller than the pivot value (i.e., it is on the wrong side)

8 6 2 11 7 54 10124 6

low high

5

pivot value

3 2


Quicksort

Then the two values are swapped and the index values are updated:

8 6 2 11 7 54 10124 6

low high

5

pivot value

32 12


Quicksort

This continues until the two index values pass each other:

8 6 12 11 7 5424 6

low high

5

pivot value

3103 10


Quicksort

This continues until the two index values pass each other:

8 6 12 11 7 5424 6

lowhigh

5

pivot value

103


Quicksort

Then the pivot value is swapped into position:

8 6 12 11 7 5424 6

lowhigh

103 85


Quicksort

Recursively quicksort the two parts:

5 6 12 11 7 8424 6103

Quicksort the left part Quicksort the right part

5


void quickSort(int array[], int size){ int index;

if (size > 1) { index = partition(array, size); quickSort(array, index); quickSort(array+index+1, size - index-1); }}

Quicksort


int partition(int array[], int size){ int k; int mid = size/2; int index = 0;

swap(array, array+mid); for (k = 1; k < size; k++){ if (array[k] < array[0]){ index++; swap(array+k, array+index); } } swap(array, array+index); return index;}

Quicksort

Data Structures-Course Recap

Arrays Link Lists Stacks Queues Binary Trees Sorting


Education

Computer notes - Mergesort