1 / 82

Understanding Recursive Algorithms: Merge Sort and Its Efficiency

This lecture covers essential concepts of recursive algorithms, focusing on the Merge Sort technique. We discuss how to break down sorting problems using the Divide and Conquer method, addressing the algorithm's structure, including the base cases and recursive calls. We analyze the efficiency class of Merge Sort, highlighting its time complexity of O(n log n) and space complexity of O(n). Suggestions for improving sorting algorithms, including Quick Sort, will also be explored, along with a review of basic operations and their execution frequencies.

chidi
Télécharger la présentation

Understanding Recursive Algorithms: Merge Sort and Its Efficiency

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lecture 5

  2. Quiz 2 Input: A nonnegative integer n S:=0 for i:=0 to n do S:=S + i*i return S • What Doest this Algorithm Compute • What is its basic operation • How many times is the basic operation executed? • What is the efficiency class of this algorithm • Suggest an improvement or a better algorithm and its efficiency class

  3. Divide and Conquer • Merge Sort • Quick Sort

  4. Divide and Conquer • Base Case, solve the problem directly if it is small enough • Divide the problem into two or more similar and smaller subproblems • Recursively solve the subproblems • Combine solutions to the subproblems

  5. Divide and Conquer - Sort Problem: • Input: A[left..right] – unsorted array of integers • Output:A[left..right] – sorted in non-decreasing order

  6. Divide and Conquer - Sort • Base case • at most one element (left ≥ right), return • DivideA into twosubarrays: FirstPart, SecondPart • Two Subproblems: • sort the FirstPart • sort the SecondPart • Recursively • sort FirstPart • sort SecondPart • Combinesorted FirstPart and sorted SecondPart

  7. Overview • Divide and Conquer • Merge Sort • Quick Sort

  8. Merge Merge Sort: Idea Divide into two halves A FirstPart SecondPart Recursively sort SecondPart FirstPart A is sorted!

  9. Merge Sort: Algorithm • Merge-Sort(A, left, right) • if left ≥ right return • else • middle ←(left+right)/2 • Merge-Sort(A, left, middle) • Merge-Sort(A, middle+1, right) • Merge(A, left, middle, right) Recursive Call

  10. Merge-Sort: Merge Sorted A: merge Sorted SecondPart SortedFirstPart A: A[right] A[left] A[middle]

  11. 5 15 28 30 6 10 14 5 2 3 7 8 1 4 5 6 R: L: 3 5 15 28 6 10 14 22 Temporary Arrays Merge-Sort: Merge Example A:

  12. Merge-Sort: Merge Example A: 3 1 5 15 28 30 6 10 14 k=0 R: L: 3 2 15 3 7 28 30 8 6 1 10 4 5 14 22 6 i=0 j=0

  13. Merge-Sort: Merge Example A: 2 1 5 15 28 30 6 10 14 k=1 R: L: 2 3 5 3 15 7 8 28 6 1 10 4 14 5 6 22 i=0 j=1

  14. Merge-Sort: Merge Example A: 3 1 2 15 28 30 6 10 14 k=2 R: L: 2 3 7 8 6 1 10 4 5 14 22 6 i=1 j=1

  15. Merge-Sort: Merge Example A: 1 2 3 6 10 14 4 k=3 R: L: 2 3 7 8 1 6 10 4 14 5 6 22 j=1 i=2

  16. Merge-Sort: Merge Example A: 1 2 3 4 6 10 14 5 k=4 R: L: 2 3 7 8 1 6 10 4 14 5 6 22 i=2 j=2

  17. Merge-Sort: Merge Example A: 6 1 2 3 4 5 6 10 14 k=5 R: L: 2 3 7 8 6 1 4 10 5 14 6 22 i=2 j=3

  18. Merge-Sort: Merge Example A: 7 1 2 3 4 5 6 14 k=6 R: L: 2 3 7 8 1 6 10 4 14 5 22 6 i=2 j=4

  19. Merge-Sort: Merge Example A: 8 1 2 3 4 5 6 7 14 k=7 R: L: 2 3 5 3 7 15 28 8 6 1 10 4 5 14 22 6 i=3 j=4

  20. Merge-Sort: Merge Example A: 1 2 3 4 5 6 7 8 k=8 R: L: 3 2 3 5 15 7 8 28 1 6 10 4 14 5 22 6 j=4 i=4

  21. Merge(A, left, middle, right) • n1 ← middle – left + 1 • n2 ← right – middle • create array L[n1], R[n2] • for i ← 0 to n1-1 do L[i] ← A[left +i] • for j ← 0 to n2-1 do R[j] ← A[middle+j] • k ← i ← j ← 0 • while i < n1 & j < n2 • if L[i] < R[j] • A[k++] ← L[i++] • else • A[k++] ← R[j++] • while i < n1 • A[k++] ← L[i++] • while j < n2 • A[k++] ← R[j++] n = n1+n2 Space: n Time : cn for some constant c

  22. Merge-Sort(A, 0, 7) Divide A: 3 7 5 1 6 2 8 4 6 2 8 4 3 7 5 1

  23. Merge-Sort(A, 0, 7) , divide Merge-Sort(A, 0, 3) A: 3 7 5 1 8 4 6 2 6 2 8 4

  24. Merge-Sort(A, 0, 7) , divide Merge-Sort(A, 0, 1) A: 3 7 5 1 8 4 2 6 6 2

  25. Merge-Sort(A, 0, 7) , base case Merge-Sort(A, 0, 0) A: 3 7 5 1 8 4 2 6

  26. Merge-Sort(A, 0, 7) Merge-Sort(A, 0, 0), return A: 3 7 5 1 8 4 2 6

  27. Merge-Sort(A, 0, 7) , base case Merge-Sort(A, 1, 1) A: 3 7 5 1 8 4 6 2

  28. Merge-Sort(A, 0, 7) Merge-Sort(A, 1, 1), return A: 3 7 5 1 8 4 2 6

  29. Merge-Sort(A, 0, 7) Merge(A, 0, 0, 1) A: 3 7 5 1 8 4 2 6

  30. Merge-Sort(A, 0, 7) Merge-Sort(A, 0, 1), return A: 3 7 5 1 8 4 2 6

  31. Merge-Sort(A, 0, 7) , divide Merge-Sort(A, 2, 3) A: 3 7 5 1 2 6 4 8 8 4

  32. Merge-Sort(A, 0, 7) Merge-Sort(A, 2, 2), base case A: 3 7 5 1 2 6 4 8

  33. Merge-Sort(A, 0, 7) Merge-Sort(A, 2, 2),return A: 3 7 5 1 2 6 4 8

  34. Merge-Sort(A, 0, 7) Merge-Sort(A, 3, 3), base case A: 2 6 8 4

  35. Merge-Sort(A, 0, 7) Merge-Sort(A, 3, 3), return A: 3 7 5 1 2 6 4 8

  36. Merge-Sort(A, 0, 7) Merge(A, 2, 2, 3) A: 3 7 5 1 2 6 4 8

  37. Merge-Sort(A, 0, 7) Merge-Sort(A, 2, 3), return A: 3 7 5 1 4 8 2 6

  38. Merge-Sort(A, 0, 7) Merge(A, 0, 1, 3) A: 3 7 5 1 2 4 6 8

  39. Merge-Sort(A, 0, 7) Merge-Sort(A, 0, 3), return A: 2 4 6 8 3 7 5 1

  40. Merge-Sort(A, 0, 7) Merge-Sort(A, 4, 7) A: 2 4 6 8 3 7 5 1

  41. Merge-Sort(A, 0, 7) Merge (A, 4, 5, 7) A: 2 4 6 8 1 3 5 7

  42. Merge-Sort(A, 0, 7) Merge-Sort(A, 4, 7), return A: 2 4 6 8 1 3 5 7

  43. Merge-Sort(A, 0, 7) Merge-Sort(A, 0, 7), done! Merge(A, 0, 3, 7) A: 1 2 3 4 5 6 7 8

  44. Merge-Sort Analysis cn n 2 × cn/2 = cn n/2 n/2 log n levels 4 × cn/4 = cn n/4 n/4 n/4 n/4 n/2 × 2c = cn 2 2 2 Total: cn log n • Total running time:(nlogn) • Total Space: (n)

  45. Merge-Sort Summary Approach: divide and conquer Time • Most of the work is in the merging • Total time: (n log n) Space: • (n), more space than other sorts.

  46. Overview • Divide and Conquer • Merge Sort • Quick Sort

  47. Quick Sort • Divide: • Pick any element p as the pivot, e.g, the first element • Partition the remaining elements into FirstPart,which contains all elements< p SecondPart, which contains all elements ≥ p • Recursively sort the FirstPart and SecondPart • Combine: no work is necessary since sorting is done in place

  48. Partition Recursive call p p p p ≤ x p ≤ x Sorted FirstPart Sorted SecondPart x < p Quick Sort A: pivot FirstPart SecondPart x < p Sorted

  49. Quick Sort Quick-Sort(A, left, right) ifleft ≥ right return else middle ← Partition(A, left, right) Quick-Sort(A, left, middle–1 ) Quick-Sort(A, middle+1, right) end if

  50. p x < p p p ≤ x x < p p ≤ x p Partition A: A: A: p

More Related