Module II

Syllabus: Divide and Conquer General method, Binary Search, finding

maximum and minimum, merge sort. Quick sort, performance measurement
of quick sort, selection, Strassen’s matrix multiplication

Divide and Conquer General method

Divide and conquer is a design strategy which is well known to
breaking down efficiency barriers. When the method applies, it often leads
to a large improvement in time complexity. For example, from O (n2 ) to O
(n log n) to sort the elements. In divide and conquer approach, a
problem is divided into smaller problems, then the smaller problems are
solved independently, and finally the solutions of smaller problems are
combined into a solution for the large problem.
Generally, divide-and-conquer algorithms have three parts −
 Divide the problem into a number of sub-problems that are smaller
instances of the same problem.
 Conquer the sub-problems by solving them recursively. If they are
small enough, solve the sub-problems as base cases.
 Combine the solutions to the sub-problems into the solution for the
original problem.

Fundamental of Divide & Conquer Strategy:

There are two fundamental of Divide & Conquer Strategy:

1. Relational Formula
2. Stopping Condition
1. Relational Formula: It is the formula that we generate from the given
technique. After generation of Formula we apply D&C Strategy, i.e. we break
the problem recursively & solve the broken subproblems.

2. Stopping Condition: When we break the problem using Divide &

Conquer Strategy, then we need to know that for how much time, we need to
apply divide & Conquer. So the condition where the need to stop our
recursion steps of D&C is called as Stopping Condition.

Pros and cons of Divide and Conquer Approach

 Divide and conquer approach supports parallelism as sub-problems

are independent. Hence, an algorithm, which is designed using this

1
 technique, can run on the multiprocessor system or in different
machines simultaneously.
 In this approach, most of the algorithms are designed using recursion,
hence memory management is very high. For recursive function stack
is used, where function state needs to be stored.

Application of Divide and Conquer Approach

Following are some problems, which are solved using divide and conquer
approach.
 Finding the maximum and minimum of a sequence of numbers
 Strassen’s matrix multiplication
 Merge sort
 Binary search

Control Abstraction of Divide and Conquer

A control abstraction is a procedure whose flow of control is clear but

whose primary operations are specified by other procedures whose
precise meanings are left undefined. The control abstraction for divide
and conquer technique is DANDC(P), where P is the problem to be solved.

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));
}
}

SMALL (P) is a Boolean valued function which determines whether the

input size is small enough so that the answer can be computed without
splitting. If this is so function ‘S’ is invoked otherwise, the problem ‘p’ into
smaller sub problems. These sub problems p1, p2, . . . , pk are solved by
recursive application of DANDC

If the sizes of the two sub problems are approximately equal then the
computing time of DANDC is:

2
 Binary Search

 Binary Search is one of the fastest searching algorithms.

 It is used for finding the location of an element in a linear array.
 It works on the principle of divide and conquer technique.
 Binary Search Algorithm can be applied only on Sorted arrays. So,
the elements must be arranged in-Either ascending order if the
elements are numbers or dictionary order if the elements are strings.
Steps:-

1. In Binary Search technique, we search an element in a sorted array by

recursively dividing the interval in half.

2. Firstly, we take the whole array as an interval.

3. If the Pivot Element (the item to be searched) is less than the item in the
middle of the interval, We discard the second half of the list and recursively
repeat the process for the first half of the list by calculating the new middle
and last element.

4. If the Pivot Element (the item to be searched) is greater than the item in
the middle of the interval, we discard the first half of the list and work
recursively on the second half by calculating the new beginning and middle
element.

5. Repeatedly, check until the value is found or interval is empty.

Analysis:
1. Input: an array A of size n, already sorted in the ascending or
descending order.
2. Output: analyze to search an element item in the sorted array of size
n.
3. Logic: Let T (n) = number of comparisons of an item with n elements
in a sorted array.

3
 o Set low = 1 and high = n
o Find mid =(low+high)/2
o Compare the search item with the mid item.

Binary Search Algorithm Advantages-

The advantages of binary search algorithm are-

 It eliminates half of the list from further searching by using the result of
each comparison.
 It indicates whether the element being searched is before or after the
current position in the list.
 This information is used to narrow the search.
 For large lists of data, it works significantly better than linear search.

Binary Search Algorithm Disadvantages-

The disadvantages of binary search algorithm are-

 It employs recursive approach which requires more stack space.

 Programming binary search algorithm is error prone and difficult.
 The interaction of binary search with memory hierarchy i.e. caching is
poor.
(because of its random access nature)

4
5
 Time Complexity Analysis-
Binary Search time complexity analysis is done below-

 In each iteration or in each recursive call, the search gets reduced to half
of the array.
 So for n elements in the array, there are log 2n iterations or recursive calls.
Thus, we have-
Time Complexity of a successful Binary Search Algorithm is O(log2n) and for an
unsuccessful search is Θ(log n).Here, n is the number of elements in the sorted linea
array.

FINDING THE MAXIMUM AND MINIMUM

The problem is to find the maximum and minimum items in a set of n
elements.

1. Let us consider simple problem that can be solved by the divide-and

conquer technique.
2. The problem is to find the maximum and minimum value in a set of ‘n’
elements.

6
 3. By comparing numbers of elements, the time complexity of this
algorithm can be analyzed.
4. Hence, the time is determined mainly by the total cost of the element
comparison.

Explanation:
a. Straight MaxMin requires 2(n-1) element comparisons in the best, average
& worst cases.
b. By realizing the comparison of a [i]max is false, improvement in a
algorithm can be done.
c. Hence we can replace the contents of the for loop by, If (a [i]> Max) then
Max = a [i]; Else if (a [i]< 2(n-1)
d. On the average a[i] is > max half the time, and so, the avg. no. of
comparison is 3n/2-1.

A Divide and Conquer Algorithm for this problem would proceed as

follows:
a. Let P = (n, a [i],……,a [j]) denote an arbitrary instance of the problem.
b. Here ‘n’ is the no. of elements in the list (a [i],….,a[j]) and we are
interested in finding the maximum and minimum of the list.
c. If the list has more than 2 elements, P has to be divided into smaller
instances.
d. For example, we might divide ‘P’ into the 2 instances, P1=([n/2],a[1],
……..a[n/2]) & P2= ( n-[n/2], a[[n/2]+1],….., a[n]) After having divided ‘P’
into 2 smaller sub problems, we can solve them by recursively invoking the
same divide-and-conquer algorithm.

7
Algorithm:

Example:

8
A 1 2 3 4 5 6 7 8 9

Values 22 13 -5 -8 15 60 17 31 47

A good way of keeping track of recursive calls is to build a tree by adding a

node each time a new call is made. For this algorithm each node has four
items of information:i,j,max,min
Tree Diagram:

MaxMin will be slower than StrightMaxMin because of the overhead of

stacking I,j,max and min for recursion.Both MaxMin and StraightMaxMin are