Scribd
Upload
75 views11 pages

Chapter 2 AA

The document discusses the divide and conquer algorithm design strategy. It begins by describing the general method of divide and conquer which involves dividing a problem into smaller subproblems, solving the subproblems recursively, and then combining the solutions to solve the original problem. It then provides examples of divide and conquer algorithms including binary search, finding maximum and minimum elements, merge sort, and quicksort. For each algorithm, it explains the divide and conquer approach, providing pseudocode and analyzing the time complexity.

Uploaded by

selemon Gamo
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
75 views11 pages

Chapter 2 AA

The document discusses the divide and conquer algorithm design strategy. It begins by describing the general method of divide and conquer which involves dividing a problem into smaller subproblems, solving the subproblems recursively, and then combining the solutions to solve the original problem. It then provides examples of divide and conquer algorithms including binary search, finding maximum and minimum elements, merge sort, and quicksort. For each algorithm, it explains the divide and conquer approach, providing pseudocode and analyzing the time complexity.

Uploaded by

selemon Gamo
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 11

ANALYSIS OF ALGORITHM

CHAPTER TWO: DIVIDE AND CONQUER

THE GENERAL METHOD


The most-well known algorithm design strategy:
1. Divide instance of problem into two or more smaller instances
2. Solve smaller instances recursively
3. Obtain solution to original (larger) instance by combining these solutions

Control Abstraction for Divide & Conquer


Algorithm DAndC(P)
{
if Small(P) then return S(P);
else
{
divide P into smaller instances P1, P2, …,Pk, K≥1;
Apply DAndC to each of these sub problems;
return Combine(DAndC(p1), DAndC(p2),…DAndC(pk));
}
}
Analysis
 Input size =n;
 g(n) = time taken to compute the answer directly for small
 inputs.
 f(n) = time for dividing and combing the solution to subproblems.
 T(n) = g(n) n is small
T(n1)+T(n2)+………….+T(nk)+f(n) otherwise

Chapter 2 – Divide and Conquer Algorithm Page 1


Recurrences
The complexity of many divide-and-conquer algorithms is given by recurrences of the form
T(n) = T(1) n=1;
aT(n/b) + f(n) n>1;
BINARY SEARCH
ITERATIVE BINARY SEARCH
Algorithm Bin search(a,n,x)
// Given an array a[1:n] of elements in non-decreasing
//order, n>=0,determine whether ‘x’ is present and
// if so, return ‘j’ such that x=a[j]; else return 0.
{
low:=1; high:=n;
while (low<=high) do
{
mid:=[(low+high)/2];
if (x<a[mid]) then high=mid-1;
else if(x>a[mid]) then
low=mid+1;
else return mid;
}
return 0;
}
This Binsearch has 3 input a,n, & x.
The while loop continues processing as long as there are more elements left to check.
At the conclusion of the procedure 0 is returned if x is not present, or ‘j’ is returned, such that
a[j]=x.
We observe that low & high are integer Variables such that each time through the loop either
x is found or low is increased by at least one or high is decreased at least one

RECURSIVE BINARY SEARCH

Chapter 2 – Divide and Conquer Algorithm Page 2


 We observe that low and high are integer variables such that each time through the loop
either x is found or low is increased by at least one or high is decreased by at least one.
 Thus we have two sequences of integers approaching each other and eventually low will
become greater than high causing termination in a finite number of steps if x is not
present.
 We assume that all statements work as expected and that comparisons such as x>a[mid]
are appropriately carried out.
 Initially low =1, high= n, n>=0 and a[1]<=a[2]<=……..<=a[n].
 If n=0, the while loop is not entered and is returned.
 Otherwise we observe that each time thro’ the loop the possible elements to be checked
of or equality with x and a[low], a[low+1],……..,a[mid],……a[high].
 If x=a[mid], then the algorithm terminates successfully.
 Otherwise, the range is narrowed by either increasing low to (mid+1) or decreasing high
to (mid-1).
 Clearly, this narrowing of the range does not affect the outcome of the search.
 If low becomes > than high, then ‘x’ is not present & hence the loop is exited.

Example for Binary search.


Let us select the nine entries,
-15, -6, 0, 7, 9, 23, 54, 82, 101
place them in A(1:9), and simulate the steps that BINSRCH goes through as it searches for
different values of x.

Chapter 2 – Divide and Conquer Algorithm Page 3


FINDING MAXIMUM AND MINIMUM
STRAIGHT FORWARD METHOD

 Straight MaxMin requires 2(n-1) element comparison in the best, average & worst
cases.
 An immediate improvement is possible by realizing that the comparison a[I]<min is
necessary only when a[I]>max is false.
 An immediate improvement is possible by realizing that the comparison a[I]<min is
necessary only when a[I]>max is false.
 Hence we can replace the contents of the for loop by,
If(a[I]>max) then max:=a[I];
Else if (a[I]<min) then min:=a[I];
 Now the best case occurs when the elements are in increasing order.
The no. of element comparison is (n-1).
 The worst case occurs when the elements are in decreasing order.
The no. of elements comparison is 2(n-1)
 The average no. of element comparison is < than 2(n-1)

DIVIDE-AND-CONQUER METHOD

Chapter 2 – Divide and Conquer Algorithm Page 4


Chapter 2 – Divide and Conquer Algorithm Page 5
MERGE SORT

 Given a sequence of n elements (also called keys) A(l), ... , A(n) the general idea is to
imagine them split into two sets A(l), ... , A( [n/2]) and A( [n/2] + 1), ... , A(n).
 Each set is individually sorted and the resulting sequences are merged to produce a
single sorted sequence of n elements.
 Thus we have another ideal example of the divide-and-conquer strategy where the
splitting is into two equal size sets and the combining operation is the merging of two
sorted sets into one.

Chapter 2 – Divide and Conquer Algorithm Page 6


 Procedure MERGESORT describes this process very succinctly using recursion and a
sub procedure MERGE which merges together two sorted sets.

Chapter 2 – Divide and Conquer Algorithm Page 7


Before executing procedure MERGESORT, the n elements should be placed in A(l:n) and the
auxiliary array B(l:n) should also be declared. Then call MERGESORT(l, n) will cause the
keys to be rearranged into non decreasing order in A.

Consider the array of 10 elements a[1:10] =(310, 285, 179, 652, 351, 423, 861,254, 450, 520)
 Algorithm Mergesort begins by splitting a[] into 2 sub arrays each of size five(a[1:5]
and a[6:10]).
 The elements in a[1:5] are then split into 2 sub arrays of size 3 (a[1:3] ) and 2(a[4:5])
 Then the items in a a[1:3] are split into sub arrays of size 2 a[1:2] & one (a[3:3])
 The 2 values in a[1:2] are split to find time into one-element sub arrays, and now the
merging begins.
(310| 285| 179| 652, 351| 423, 861, 254, 450, 520)
 Where vertical bars indicate the boundaries of sub arrays.
 Elements a[I] and a[2] are merged to yield,
(285, 310|179|652, 351| 423, 861, 254, 450, 520)
 Then a[3] is merged with a[1:2] and
(179, 285, 310| 652, 351| 423, 861, 254, 450, 520)
 Next, elements a[4] & a[5] are merged.

Chapter 2 – Divide and Conquer Algorithm Page 8


(179, 285, 310| 351, 652 | 423, 861, 254, 450, 520)
 And then a[1:3] & a[4:5]
(179, 285, 310, 351, 652| 423, 861, 254, 450, 520)
 Repeated recursive calls are invoked producing the following sub arrays.
(179, 285, 310, 351, 652| 423| 861| 254| 450, 520)
 Elements a[6] &a[7] are merged.
 Then a[8] is merged with a[6:7]
(179, 285, 310, 351, 652| 254,423, 861| 450, 520)
 Next a[9] &a[10] are merged, and then a[6:8] & a[9:10]
(179, 285, 310, 351, 652| 254, 423, 450, 520, 861 )
 At this point there are 2 sorted sub arrays & the final merge produces the fully
sorted result.
(179, 254, 285, 310, 351, 423, 450, 520, 652, 861)

 If the time for the merging operations is proportional to ‘n’, then the computing time for
merge sort is described by the recurrence relation.
T(n) = { a n=1,’a’ a constant
2T(n/2)+cn n>1,’c’ a constant

QUICK SORT
 In merge sort, the file a[1:n] was divided at its midpoint into sub arrays which were
independently sorted & later merged.
 In Quick sort, the division into 2 sub arrays is made so that the sorted sub arrays do not
need to be merged later.
 This is accomplished by rearranging the elements in a[1:n] such that a[I]<=a[j] for all i
between 1 & n and all j between (m+1) & n for some m, 1<=m<=n.
 Thus the elements in a[1:m] & a[m+1:n] can be independently sorted.
 No merge is needed. This rearranging is referred to as partitioning.
 Function partition of Algorithm accomplishes an in-place partitioning of the elements of
a[m:p-1]
 It is assumed that a[p]>=a[m] and that a[m] is the partitioning element. If m=1 & p-1=n,
then a[n+1] must be defined and must be greater than or equal to all elements in a[1:n]

Chapter 2 – Divide and Conquer Algorithm Page 9


 The assumption that a[m] is the partition element is merely for convenience, other choices
for the partitioning element than the first item in the set are better in practice.
 The function interchange (a,i,j) exchanges a[i] with a[j].

Chapter 2 – Divide and Conquer Algorithm Page


10
Chapter 2 – Divide and Conquer Algorithm Page
11

You might also like