Scribd
Upload
18 views19 pages

Unit Ii Divide and Conquer

This document covers the Divide and Conquer strategy, focusing on the Merge Sort algorithm, which sorts a list by recursively dividing it into halves, sorting those halves, and then merging them back together. It includes detailed steps for implementing the Merge Sort function, the Merge function, and an analysis of the algorithm's time complexity using the Master’s theorem. The overall complexity of Merge Sort is established as Θ(n log n).

Uploaded by

Sanjay Baskar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
18 views19 pages

Unit Ii Divide and Conquer

This document covers the Divide and Conquer strategy, focusing on the Merge Sort algorithm, which sorts a list by recursively dividing it into halves, sorting those halves, and then merging them back together. It includes detailed steps for implementing the Merge Sort function, the Merge function, and an analysis of the algorithm's time complexity using the Master’s theorem. The overall complexity of Merge Sort is established as Θ(n log n).

Uploaded by

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

UNIT II

DIVIDE AND CONQUER

Session – 10
Syllabus
⚫ Introduction, Binary Search - Merge sort and its
algorithm analysis - Quick sort and its algorithm
analysis - Strassen's Matrix multiplication - Finding
Maximum and minimum - Algorithm for finding closest
pair - Convex Hull Problem
Introduction
⚫ Divide / Break
⚫ Conquer / Solve
⚫ Merge / Combine
Merge Sort algorithm
⚫ Merge sort is based on Divide and conquer method.
⚫ It takes the list to be sorted and divide it in half to create two unsorted lists.
⚫ The two unsorted lists are then sorted and merged to get a sorted list.
⚫ The two unsorted lists are sorted by continually calling the merge-sort algorithm; we
eventually get a list of size 1 which is already sorted. The two lists of size 1 are then
merged.
Steps using Divide and Conquer strategy
⚫ Step 1 − if it is only one element in the list it is already sorted, return.
⚫ Step 2 − divide the list recursively into two halves until it can no more be divided.
⚫ Step 3 − merge the smaller lists into new list in sorted order.
MergeSort(arr[], l, r)

If r > l

1. Find the middle point to divide the array into two halves:

middle m = (l+r)/2

2. Call mergeSort for first half:

Call mergeSort(arr, l, m)

3. Call mergeSort for second half:

Call mergeSort(arr, m+1, r)

4. Merge the two halves sorted in step 2 and 3:

Call merge(arr, l, m, r)
Mergesort(A,p,r)
Mergesort() function
MERGE-SORT (A, p, r)
1. WHILE p < r // Check for base case
2. q = FLOOR[(p + r)/2] // Divide step
3. MERGE-SORT (A, p, q)
4. MERGE-SORT (A, q + 1, r)
5. MERGE (A, p, q+1, r)

⚫ MergeSort() function / Split step


⚫ We find the middle index using start and end index of the input array
and again invoke the same function with two parts one starting from
start to mid and other being from mid+1 to end.
⚫ Once base condition is hit, we start winding up and call merge function.
Mergesort(A,p,r)
Merge() function
⚫ MERGE (A, p, q, r ) //A –array, p – start index, q – middle,
r – last index
//Merges two subarrays of arr[].First subarray is arr[p..q] Second subarray is
arr[q+1..r]
1. n1 ← q − p + 1
2. n2 ← r − q
// Create temperary arrays L[1 .. n1+1] and R[1 ..n2+1]
3. FOR i ← 1 to n1
4. do L[i] ← A[p + i − 1]
5. FOR j ← 1 TO n2
6. DO R[j] ← A[q + j ]
7. L[n1 + 1] ← ∞
8. R[n2 + 1] ← ∞
9. i ← 1
10.j ← 1
11. for k ← p to r
12. Do if L[i ] ≤ R[ j]
13. then A[k] ← L[i]
14. i←i+1
15. else A[k] ← R[j]
16. j←j+1
⚫ Merge() function / Merge step
⚫ Merge function merges two sub arrays
(one from start to mid and other from
mid+1 to end) into a single array from
start to end. This array is then returned
to upper calling function which then again
sort two parts of array.
Merge sort analysis
⚫ For simplicity, assume that n is a power of 2 so that each
divide step yields two subproblems, both of size exactly n/2.
⚫ The base case occurs when n = 1.
⚫ When n ≥ 2, time for merge sort steps:
⚫ Divide: Just compute q as the average of p and r, which
takes constant time i.e. Θ(1).
⚫ Conquer: Recursively solve 2 subproblems, each of
size n/2, which is 2T(n/2).
⚫ Combine: MERGE on an n-element subarray takes Θ(n)
time.
⚫ Summed together they give a function that is linear in n,
which is Θ(n). Therefore, the recurrence for merge sort
running time is
Using Master’s theorem
T(n) = 2T(n/2) + ϴ(n)
T(n) = aT(n/b) + f(n) where a >= 1 and b > 1
a=2 b=2 f(n) = n
1. If f(n) < O(nlogba), then T (n) = ϴ (nlogba).
2. If f(n) = ϴ (nlogbalogkn) with k≥0, then T (n) = ϴ (nlogbalogk+1n).
3. If f(n) > Ω (nlogba), and f(n) satisfies the regularity condition,
then T (n) = ϴ (f(n)).
Calculate nlogba = nlog22 = n
Compare with f(n). Since f(n) = nlogba
i.e. n = n
Case 2 is satisfied hence complexity is given as
T(n) = Θ(f(n)logn) = Θ (nlogn)
Video for Merge sort
Merge sort
Worksheet No. 10

You might also like