Data Structures - 12. Recursion, II

Universidade Federal da ParaíbaCentro de Informática

Recursion IILecture 15

1107186 – Estrutura de Dados – Turma 02

Prof. Christian Azambuja PagotCI / UFPB

2Universidade Federal da ParaíbaCentro de Informática

Divide-and-Conquer Algorithms

● Divide-and-conquer algorithms can be characterized by:– Subdivision of the original problem into smaller

ones of the same type.

– Multi-branched recursion.

● Example:– Merge Sort


Merge Sort

● It is a divide-and-conquer-based sorting algorithm, with worst case O(n log n).

● Algorithm:– Division: The initial sequence of n numbers is

recursively split into 2 sequences of length n/2 until the length of each sequence is 1.

– Conquer: Sort the subproblems recursively.

– Combine: The 2 sequences are combined.


Merge Sort

● It is composed by two functions:– MergeSort: recursively splits the input vector of

length n into 2 vectors of length n/2.

– Merge: Combine two separate pre sorted vectors into an ordered vector.


MergeSort() Function

void MergeSort(int* v, int p, int r){

int q;

if (p<r){

q = (int) (p+r) / 2.0f;MergeSort(v, p, q);MergeSort(v, q+1, r);Merge(v, p, q, r);

}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p=q r

0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p=r




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p=q r

0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p=r




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

10 1 9 3 7 8 4 2 6 5

p=q r




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p=q r




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p=r




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p rq




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p=q r

0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p=r




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p=q r

0 1 2 3 4 5 6 7 8 9

1 10 9 3 7 8 4 2 6 5

p=r




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p=q r




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p=q r




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

1 3 7 9 10 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 3 7 9 10 8 4 2 6 5

p rq




int q;

if (p<r){


}}

C code excerpt:

...

MergeSort(v, 0, 9);

v = 0 1 2 3 4 5 6 7 8 9

1 3 7 9 10 8 4 2 6 5

p rq

0 1 2 3 4 5 6 7 8 9

1 3 7 9 10 8 4 2 6 5

p rq

And so on!!!

...


Merge() Function


int q;

if (p<r){


}}

C code excerpt:0 1 2 3 4 5 6 7 8 9

1 9 10 3 7 8 4 2 6 5

p rq

v =

0 1 2 3 4 5 6 7 8 9

1 3 7 9 10 8 4 2 6 5

p rq


Merge() Function

int Merge(int* v, int p, int q, int r) {int i, j, k;int n1 = q p + 1;int n2 = r q;int* left = (int*) malloc((n1 + 1) * sizeof(int));int* right = (int*) malloc((n2 + 1) * sizeof(int));

for (i=0; i<n1; i++)left[i] = v[p + i];

for (j=0; j<n2; j++)right[j] = v[q + 1 + j];

left[n1] = INT_MAX; right[n2] = INT_MAX;i = 0; j = 0;for (k=p; k<=r; k++)

if (left[i] <= right[j]) {v[k] = left[i];i += 1;

}else {

v[k] = right[j];j += 1;

}free(left); free(right);

}

C code excerpt:


Merge() Function






}else {

v[k] = right[j];j += 1;


}

C code excerpt:


Merge() Function






}else {

v[k] = right[j];j += 1;


}

C code excerpt:


Merge() Function






}else {

v[k] = right[j];j += 1;


}

C code excerpt:







}else {

v[k] = right[j];j += 1;


}

C code excerpt:

Merge() Function


int Merge(int* v, int p, int q, int r) { int i, j, k; int n1 = q p + 1; int n2 = r q; int* left = (int*) malloc((n1 + 1) * sizeof(int)); int* right = (int*) malloc((n2 + 1) * sizeof(int));

for (i=0; i<n1; i++) left[i] = v[p + i]; for (j=0; j<n2; j++) right[j] = v[q + 1 + j];

left[n1] = INT_MAX; right[n2] = INT_MAX; i = 0; j = 0; for (k=p; k<=r; k++) if (left[i] <= right[j]) { v[k] = left[i]; i += 1; } else { v[k] = right[j]; j += 1; } free(left); free(right);}

C code excerpt:

Cost of the Merge() Function

…... Constant cost

…..............…... Constant cost

….............….................…... O(n1 + n2) = O(n)

….............….................... O(n)


Cost of the MergeSort() Function

● If the algorithm is recursive, its running time can be described by a recurrence:– T(n) is the running time on a problem of size n.

– If n <= c (c is a constant), time is constant.



● Our division problem step yields a subproblems, each of wich is 1/b the size of the original (for Merge Sort a = b = 2).

● It takes time T(n/b) to solve one subproblem of size n/b.

● It takes aT(n/b) to solve a such subproblems.● Subdivision takes D(n) time.● Combination takes C(n) time.



● Thus, we get the following recurrence:

T (n)={ Θ(1) , if n≤caT (n/b)+D(n)+C (n)otherwise.



● With respect to Merge Sort:– Subdivision: computes the middle of the

subarray. Time: D(n) = Θ(1).

– Conquer: solves 2 problems with size n/2. Time: 2T(n/2).

– Combine: Merge = Θ(n).

● Thus, the related recurrence can be rewritten as:

T (n)={ Θ(1) , if n=12T (n /2)+Θ(n) ,if n>1.



● We can rewrite the recurrence

as

where c is the cost to execute a unique operation.

T (n)={ Θ(1) , if n=12T (n /2)+Θ(n) ,if n>1.

T (n)={ c ,if n=12T (n /2)+cn ,if n>1.


Computing the Total Cost of the MergeSort Algorithm

T (n)

T (n)={ c ,if n=12T (n /2)+cn ,if n>1.



cn

T (n/2) T (n/2)

T (n)={ c ,if n=12T (n /2)+cn ,if n>1.



cn

cn /2 cn /2

T (n/ 4) T (n/ 4) T (n/ 4) T (n/ 4)

T (n)={ c ,if n=12T (n /2)+cn ,if n>1.



cn

cn /2 cn /2

c c c c

Height = log2n + 1

cn

cn

cn

+

+

Total cost: cn log2n + cn

Total cost: cn log2n

Total cost O(n log2n)

T (n)={ c ,if n=12T (n /2)+cn ,if n>1.

Data Structures - 12. Recursion, II

Education

recurrenceast n

c c c ct n

log2n34 universidade

cn log2ntotal cost

input vector oflength

cntotal cost

algorithms divide

vectors of length n2