Subject Name: Design and Analysis of Algorithm Subject Code: 10CS43 Prepared By: Shruthi N Department: CSE Date: 5/25/2018

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

Divide-and-Conquer Technique (cont.) 3 Divide-and-Conquer Technique (cont.) a problem of size n subproblem 1 of size n/2 subproblem 2 of size n/2 a solution to subproblem 1 a solution to subproblem 2 a solution to the original problem It general leads to a recursive algorithm!

Divide-and-Conquer Examples 4 Divide-and-Conquer Examples Sorting: mergesort and quicksort Binary tree traversals Binary search (?) Defective chess board

Divide-and-Conquer Recurrence 5 Divide-and-Conquer Recurrence Let T(n) be a monotonically increasing function that satisfies T(n) = a T(n/b) + f(n) T(1) = c where a  1, b  2, c>0. If f(n) is (nd) where d  0 then if a < bd T(n) = If a = bd if a > bd

6 Mergesort Split array A[0..n-1] into about equal halves and make copies of each half in arrays B and C Sort arrays B and C recursively Merge sorted arrays B and C into array A as follows: Repeat the following until no elements remain in one of the arrays: compare the first elements in the remaining unprocessed portions of the arrays copy the smaller of the two into A, while incrementing the index indicating the unprocessed portion of that array Once all elements in one of the arrays are processed, copy the remaining unprocessed elements from the other array into A.

Pseudocode of Mergesort 7 Pseudocode of Mergesort

8 Pseudocode of Merge Time complexity: Θ(p+q) = Θ(n) comparisons

Mergesort Example 12/8/13

Analysis of Mergesort All cases have same efficiency: Θ(n log n) 1010 even if not analyzing in detail, show the recurrence for mergesort in worst case: T(n) = 2 T(n/2) + (n-1) worst case comparisons for merge Analysis of Mergesort All cases have same efficiency: Θ(n log n) Number of comparisons in the worst case is close to theoretical minimum for comparison-based sorting: . Space requirement: Θ(n) (not in-place) Can be implemented without recursion (bottom-up) T(n) = 2T(n/2) + Θ(n), T(1) = 0

1111 Quicksort Select a pivot (partitioning element) – here, the first element. Rearrange the list so that all the elements in the first ‘s’ positions are smaller than or equal to the pivot and all the elements in the remaining n-s positions are larger than or equal to the pivot. Exchange the pivot with the last element in the first subarray — the pivot is now in its final position. Sort the two subarrays recursively.

Partitioning Algorithm 1212 Partitioning Algorithm or i > r or j = l < Time complexity: Θ(r-l) comparisons

1313 Quicksort Example 5 3 1 9 8 2 4 7 2 3 1 4 5 8 9 7 1 2 3 4 5 7 8 9

Analysis of Quicksort Best case: split in the middle — Θ(n log n) 1414 Analysis of Quicksort Best case: split in the middle — Θ(n log n) Worst case: sorted array! — Θ(n2) Average case: random arrays — Θ(n log n) Improvements: better pivot selection: median of three partitioning switch to insertion sort on small subfiles elimination of recursion These combine to 20-25% improvement Considered the method of choice for internal sorting of large files (n ≥ 10000)

1515 Binary Search public static int binarySearch(int [ ] list, int listLength, int key) { int first = 0, last = listLength - 1; int mid; boolean found = false; while (first <= last && !found) { mid = (first + last) / 2; if (list[mid] == key) found = true; else if(list[mid] > key) last = mid - 1; first = mid + 1; } if (found) return mid; return –1; } //end binarySearch

Analysis of Binary Search 1616 Analysis of Binary Search Time efficiency: This is VERY fast. Optimal for searching a sorted array Limitations: Must be a sorted array (not linked list) Bad (degenerate) example of divide-and-conquer because only one of the sub-instances is solved Has a continuous counterpart called bisection method for solving equations in one unknown f(x) = 0

Defective chess board The total idea of chessboard coverage algorithm based on the divide-and-conquer strategy in the teaching materials is to divide the chessboard into four sub-chessboards first, and then respectively cover these four sub- chessboards. 12/8/13

Contd.. For each sub-chessboard, the program will first judge whether the special pane is in this sub- chessboard. If it is in the sub-chessboard, the program will recursively transfer the program to cover this sub-chessboard, or else, cover the neighboring panes with other three sub- chessboards, and then recursively transfer the program to cover this sub-chessboard. 12/8/13

1919 Assignment questions 1. What is brute-force method? Write a brute-force string matching algorithm. Analyze its complexity. 2. Write the quick sort algorithm. Analyze its efficiency. Apply the algorithm to sort the list 4, 1, 6, 3, 9, 2, 7, 5 . 3. Using quick sort algorithm. Arrange the letters of the word a” EXAMPLE” in alphabetical order . 4. Using quick sort algorithm. Arrange the letters of the word a” QUESTION” in alphabetical order. 5. Write the algorithm for binary search and find the average case efficiency.

1-2020 2020 Contd.. 6. Discuss the merge sort algorithm with recursive tree and its efficiency. Apply the same algorithm to sort the list {4,6,1,3,9,5} 7. Using bubble sort algorithm. Arrange the letters of the word a” QUESTION” in alphabetical order 8. Using bubble sort algorithm. Arrange the letters of the word a” EXAMPLE” in alphabetical order 9. Give the general divide and conquer recurrence and explain the same. Give the master‟s theorem. 10. What is divide-and conquer technique? Explain the concept of divide and conquer methodology indicating three major variations.

Thank You..