Data Structures and Algorithms

Lecture __ : Sorting Algorithms

Original Author of the lecture slides: Dr. Sohail Aslam

Sorting Algorithms:

Divide and Conquer Strategy

Merge Sort

Quick Sort

Divide and Conquer Strategy

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

Search

Divide and Conquer

Search

Search

Recall: Binary Search

Sort

Divide and Conquer

Sort Sort

Sort Sort Sort Sort

Divide and Conquer

Combine

Combine Combine

Merge Sort

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.

4

Mergesort

8 12 11 2 7 5410

8 12410

410

Mergesort the right half.

Merge the two halves.

104 8 12

128

Merge the two halves.

88 12

Mergesort

8 12 11 2 7 5410

8 12410

Merge the two halves.

410

Mergesort the right half. Merge the two halves.

104 8 12

10 1284

104 8 12

Mergesort

10 12 11 2 7 584

Mergesort the right half.

11 2 7 5

11 2

11 2

Mergesort

10 12 11 2 7 584

Mergesort the right half.

11 2 7 5

11 22 11

2 11

Mergesort

10 12 11 2 7 584

Mergesort the right half.

11 2 7 52 11

75

7 5

Mergesort

10 12 11 2 7 584

Mergesort the right half.

11 2 572 11

Mergesort

10 12 2 5 7 1184

Mergesort the right half.

Mergesort

5 7 8 10 11 1242

Merge the two halves.

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: b:

aSize: 5 bSize: 6

mergeArrays

tmp:

mergeArrays

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

tmp:

i=0

k=0

j=0

3 6

mergeArrays

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

tmp:

i=0

k=0

3

j=0

3 6

mergeArrays

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

tmp:

i=1 j=0

k=1

3 5

5 6

mergeArrays

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

3 5tmp:

i=2 j=0

k=2

6

15 6

mergeArrays

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

3 5 6tmp:

i=2 j=1

k=3

15 10

10

10

mergeArrays

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

3 5 6tmp:

i=2 j=2

k=4

15 10 14

14

1410

mergeArrays

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

3 5 6tmp:

i=2 j=3

k=5

15 10 22

15

1410

mergeArrays

3 5 30 6 14 43 50a: b:

3 5 6tmp:

i=3 j=3

k=6

15 10 22

2215

28

1410

mergeArrays

3 5 30 6 14 50a: b:

3 5 6tmp:

i=3 j=4

k=7

15 10 22

2815

28 43

22

1410

mergeArrays

3 5 6 14 50a: b:

3 5 6tmp:

i=4 j=4

k=8

15 10 22

3015

28 43

22

30

28

1410

mergeArrays

3 5 6 14 50a: b:

3 5 6 30tmp:

i=5 j=4

k=9

15 10 22

15

28 43

22

30

28 43 50

Done.

Merge Sort and Linked Lists

Sort Sort

Merge

Mergesort Analysis

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

Quick Sort

Quicksort

Quicksort is another divide and conquer algorithm

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

low high

5

pivot value

38 103

Quicksort

This continues until the two index values pass each other:

12 11 7 5424

lowhigh

5

pivot value

8 103

Quicksort

This continues until the two index values pass each other:

8 6 12 11 7 5424 6

lowhigh

5

pivot value

103

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

Heap-Sort

template <class eType>

void Heap<eType> :: sort()

{

int m = currentSize;

int i=0;

eType minItem;

while(m>=2)

{

minItem = array[ 1 ];

//swap root item with last child

array[1] = array[m];

array[m] = minItem;

m--;

percolateDown( 1, m );

}

}