Lecture No.

45
Data Structures

Dr. Sohail Aslam

Divide and Conquer

What if we split the list into two parts?

10 12 8 4 2 11 7 5
Divide and Conquer

Sort the two parts:

10
4 12
8 10
8 12
4 2 11
5 7 11
5
Divide and Conquer

Then merge the two parts together:

4
2 8
4 10
5 12
7 2
8 10
5 11
7 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
Divide and Conquer

Recall: Binary Search

Search

Search

Search
Divide and Conquer

Sort

Sort Sort

Sort Sort Sort Sort

Divide and Conquer

Combine

Combine Combine
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
Split the list in half. Mergesort the left half.

10 4 8 12 11 2 7 5

Split the list in half. Mergesort the left half.

10 4 8 12

Split the list in half. Mergesort the left half.

10 4

Mergesort the right.

10 4
Mergesort

10 4 8 12 11 2 7 5

10 4 8 12

Mergesort the right half. Merge the two halves.

10
4 10
4 8 12

Merge the two halves.

8 12
Mergesort

10 4 8 12 11 2 7 5

Merge the two halves.

10
4 4
8 10
8 12

Mergesort the right half. Merge the two halves.

10
4 10
4 8 12
Mergesort
Mergesort the right half.

4 8 10 12 11 2 7 5

11 2 7 5

11 2

11 2
Mergesort
Mergesort the right half.

4 8 10 12 11 2 7 5

11
2 11
2 7 5

11
2 11
2
Mergesort
Mergesort the right half.

4 8 10 12 11 2 7 5

11
2 11
2 7 5

5 7

7 5
Mergesort
Mergesort the right half.

4 8 10 12 11 2 7 5

11
2 11
2 7 5
Mergesort
Mergesort the right half.

4 8 10 12 2 5 7 11
Mergesort
Merge the two halves.

2 4 5 7 8 10 11 12
Mergesort
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];
}
}
mergeArrays

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

aSize: 5 bSize: 6

tmp:
mergeArrays

a: 3 5 15 28 30 b: 6 10 14 22 43 50
i=0 j=0

tmp:
k=0
mergeArrays

a: 3 5 15 28 30 b: 6 10 14 22 43 50
i=0 j=0

tmp: 3
k=0
mergeArrays

a: 3 5 15 28 30 b: 6 10 14 22 43 50
i=1 j=0

tmp: 3 5
k=1
mergeArrays

a: 3 5 15 28 30 b: 6 10 14 22 43 50
i=2 j=0

tmp: 3 5 6
k=2
mergeArrays

a: 3 5 15 28 30 b: 6 10 14 22 43 50
i=2 j=1

tmp: 3 5 6 10
k=3
mergeArrays

a: 3 5 15 28 30 b: 6 10 14 22 43 50
i=2 j=2

tmp: 3 5 6 10 14
k=4
mergeArrays

a: 3 5 15 28 30 b: 6 10 14 22 43 50
i=2 j=3

tmp: 3 5 6 10 14 15
k=5
mergeArrays

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

tmp: 3 5 6 10 14 15 22
k=6
mergeArrays

a: 3 5 15 28 30 b: 6 10 14 22 43 50
i=3 j=4

tmp: 3 5 6 10 14 15 22 28
k=7
mergeArrays

a: 3 5 15 28 30 b: 6 10 14 22 43 50
i=4 j=4

tmp: 3 5 6 10 14 15 22 28 30
k=8
mergeArrays

a: 3 5 15 28 30 b: 6 10 14 22 43 50
i=5 j=4

Done.

tmp: 3 5 6 10 14 15 22 28 30 43 50
k=9
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)
. O (lg n)
. times
Merging the n lists of size 1:
.

O(n)
 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):

4 12
4 10 8 5 2 11 7 3

5
pivot value
Quicksort

The pivot is swapped to the last position and the

remaining elements are compared starting at the
ends.

4 12
4 10 8 3 2 11 7 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)

4 12 10 8 6
3 2 11 7 5

low high

5
pivot value
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)

4 12
4 10 8 6
3 2 11 7 5

low high

5
pivot value
Quicksort

Then the two values are swapped and the index

values are updated:

4 12
4
2 10 8 6
3 12
2 11 7 5

low high

5
pivot value
Quicksort

This continues until the two index values pass

each other:

4 2
4 10
3 8 10
6
3 12 11 7 5

low high

5
pivot value
Quicksort

This continues until the two index values pass

each other:

4 2
4 3 8 10
6 12 11 7 5

high low

5
pivot value
Quicksort

Then the pivot value is swapped into position:

4 2
4 3 8
5 10
6 12 11 7 5
8

high low
Quicksort

Recursively quicksort the two parts:

4 2
4 3 5 10
6 12 11 7 8

Quicksort the left part Quicksort the right part

Quicksort

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;
}
Data Structures-Course Recap

 Arrays
 Link Lists
 Stacks
 Queues
 Binary Trees
 Sorting