CSE 373: Floyd s buildheap algorithm; divide-and-conquer. Michael Lee Wednesday, Feb 7, 2018

Transcription

1 CSE : Floyd s buildheap algorithm; divide-and-conquer Michael Lee Wednesday, Feb, 0

2 Warmup Warmup: Insert the following letters into an empty binary min-heap. Draw the heap s internal state in both tree and array form: c, b, a, a, a, c

3 Warmup Warmup: Insert the following letters into an empty binary min-heap. Draw the heap s internal state in both tree and array form: c, b, a, a, a, c In tree form a a b c a c

4 Warmup Warmup: Insert the following letters into an empty binary min-heap. Draw the heap s internal state in both tree and array form: c, b, a, a, a, c In tree form In array form a 0 4 a b a a b c a c c a c

5 The array-based representation of binary heaps Take a tree: A B C D E F G H I J K L

6 The array-based representation of binary heaps Take a tree: A B D H I E J K C F L G And fill an array in the level-order of the tree: A 0 B C D E 4 F G H I J 9 K L 4

7 The array-based representation of binary heaps Take a tree: A How do we find parent? i parent(i) = B C The left child? D E F G leftchild(i) = i + H I J K L The right child? leftchild(i) = i + And fill an array in the level-order of the tree: A B C D E F G H I J K L

8 Finding the last node If our tree is represented using an array, what s the time needed to find the last node now? 4

9 Finding the last node If our tree is represented using an array, what s the time needed to find the last node now? Θ (): just use this.array[this.size - ]. 4

10 Finding the last node If our tree is represented using an array, what s the time needed to find the last node now? Θ (): just use this.array[this.size - ]....assuming array has no gaps. (Hey, it looks like the structure invariant was useful after all) 4

11 Re-analyzing insert How does this change runtime of insert?

12 Re-analyzing insert How does this change runtime of insert? Runtime of insert: findlastnodetime+addnodetolasttime+numswaps swaptime...which is: + + numswaps

13 Re-analyzing insert How does this change runtime of insert? Runtime of insert: findlastnodetime+addnodetolasttime+numswaps swaptime...which is: + + numswaps Observation: when percolating, we usually need to percolate up a few times! So, numswaps in the average case, and numswaps height = log(n) in the worst case!

14 Re-analyzing removemin How does this change runtime of removemin?

15 Re-analyzing removemin How does this change runtime of removemin? Runtime of removemin: findlastnodetime + removeroottime + numswaps swaptime...which is: + + numswaps

16 Re-analyzing removemin How does this change runtime of removemin? Runtime of removemin: findlastnodetime + removeroottime + numswaps swaptime...which is: + + numswaps Observation: unfortunately, in practice, usually must percolate all the way down. So numswaps height log(n) on average.

17 Project Deadlines: Partner selection: Fri, Feb 9 Part : Fri, Feb Parts and : Fri, Feb Make sure to... Find a different partner for project...or me and petition to keep your current partner

18 Grades Some stats about the midterm: Mean and median 0 (out of 0) Standard deviation

19 Grades Common questions: I want to know how to do better next time Feel free to schedule an appointment with me. 9

20 Grades Common questions: I want to know how to do better next time Feel free to schedule an appointment with me. How will final grades be curved? Not sure yet. 9

21 Grades Common questions: I want to know how to do better next time Feel free to schedule an appointment with me. How will final grades be curved? Not sure yet. I want a midterm regrade. Wait a day, then me. 9

22 Grades Common questions: I want to know how to do better next time Feel free to schedule an appointment with me. How will final grades be curved? Not sure yet. I want a midterm regrade. Wait a day, then me. I want a regrade on a project or written homework Fill out regrade request form on course website. 9

23 An interesting extension We discussed how to implement insert, where we insert one element into the heap.

24 An interesting extension We discussed how to implement insert, where we insert one element into the heap. What if we want to insert n different elements into the heap?

25 An interesting extension Idea : just call insert n times total runtime of Θ (n log(n))

26 An interesting extension Idea : just call insert n times total runtime of Θ (n log(n)) Can we do better? Yes! Possible to do in Θ (n) time, using Floyd s buildheap algorithm.

27 Floyd s buildheap algorithm The basic idea: Start with an array of all n elements Start traversing backwards e.g. from the bottom of the tree to the top Call percolatedown(...) per each node

28 Floyd s buildheap algorithm: example A visualization:

29 Floyd s buildheap algorithm: example A visualization:

30 Floyd s buildheap algorithm: example A visualization:

31 Floyd s buildheap algorithm: example A visualization:

32 Floyd s buildheap algorithm: example A visualization:

33 Floyd s buildheap algorithm: example A visualization:

34 Floyd s buildheap algorithm: example A visualization:

35 Floyd s buildheap algorithm: example A visualization:

36 Floyd s buildheap algorithm: example A visualization:

37 Floyd s buildheap algorithm: example A visualization:

38 Floyd s buildheap algorithm: example A visualization:

39 Floyd s buildheap algorithm: example A visualization:

40 Floyd s buildheap algorithm: example A visualization:

41 Floyd s buildheap algorithm: example A visualization:

42 Floyd s buildheap algorithm: example A visualization:

43 Floyd s buildheap algorithm: example A visualization:

44 Floyd s buildheap algorithm: example A visualization:

45 Floyd s buildheap algorithm Wait... isn t this still n log(n)? We look at n nodes, and we run percolatedown(...) on each node, which takes log(n) time... right? 4

46 Floyd s buildheap algorithm Wait... isn t this still n log(n)? We look at n nodes, and we run percolatedown(...) on each node, which takes log(n) time... right? Yes algorithm is O (n log(n)), but with a more careful analysis, we can show it s O (n)! 4

47 Analyzing Floyd s buildheap algorithm Question: How much work is percolatedown actually doing?

48 Analyzing Floyd s buildheap algorithm Question: How much work is percolatedown actually doing? ( nodes) ( work)

49 Analyzing Floyd s buildheap algorithm Question: How much work is percolatedown actually doing? (4 nodes) ( work) ( nodes) ( work)

50 Analyzing Floyd s buildheap algorithm Question: How much work is percolatedown actually doing? ( nodes) ( work) (4 nodes) ( work) ( nodes) ( work)

51 Analyzing Floyd s buildheap algorithm Question: How much work is percolatedown actually doing? ( node) (4 work) ( nodes) ( work) (4 nodes) ( work) ( nodes) ( work)

52 Analyzing Floyd s buildheap algorithm Question: How much work is percolatedown actually doing? ( node) (4 work) ( nodes) ( work) (4 nodes) ( work) ( nodes) ( work) What s the pattern?

53 Analyzing Floyd s buildheap algorithm Question: How much work is percolatedown actually doing? ( node) (4 work) ( nodes) ( work) (4 nodes) ( work) ( nodes) ( work) What s the pattern? work(n) n + n 4 + n +

54 Analyzing Floyd s buildheap algorithm We had: work(n) n + n 4 + n +

55 Analyzing Floyd s buildheap algorithm We had: work(n) n + n 4 + n + Let s rewrite bottom as powers of two, and factor out the n: ( work(n) n + + ) +

56 Analyzing Floyd s buildheap algorithm We had: work(n) n + n 4 + n + Let s rewrite bottom as powers of two, and factor out the n: ( work(n) n + + ) + Can we write this in summation form? Yes.? i work(n) n i i=

57 Analyzing Floyd s buildheap algorithm We had: work(n) n + n 4 + n + Let s rewrite bottom as powers of two, and factor out the n: ( work(n) n + + ) + Can we write this in summation form? Yes.? i work(n) n i What is? supposed to be? i=

58 Analyzing Floyd s buildheap algorithm We had: work(n) n + n 4 + n + Let s rewrite bottom as powers of two, and factor out the n: ( work(n) n + + ) + Can we write this in summation form? Yes.? i work(n) n i What is? supposed to be? It s the height of the tree: so log(n). (Seems hard to analyze...) i=

59 Analyzing Floyd s buildheap algorithm We had: work(n) n + n 4 + n + Let s rewrite bottom as powers of two, and factor out the n: ( work(n) n + + ) + Can we write this in summation form? Yes.? i work(n) n i What is? supposed to be? It s the height of the tree: so log(n). (Seems hard to analyze...) So let s just make it infinity! work(n) n? i= i= i i n i= i i

60 Analyzing Floyd s buildheap algorithm Strategy: prove the summation is upper-bounded by something even when the summation goes on for infinity. If we can do this, then our original summation must definitely be upper-bounded by the same thing. work(n) n? i= i i n i= i i

61 Analyzing Floyd s buildheap algorithm Strategy: prove the summation is upper-bounded by something even when the summation goes on for infinity. If we can do this, then our original summation must definitely be upper-bounded by the same thing. work(n) n? i= i i n Using an identity (see page 4 of Weiss): work(n) n i= i= i i = n i i

62 Analyzing Floyd s buildheap algorithm Strategy: prove the summation is upper-bounded by something even when the summation goes on for infinity. If we can do this, then our original summation must definitely be upper-bounded by the same thing. work(n) n? i= i i n Using an identity (see page 4 of Weiss): work(n) n So buildheap runs in O (n) time! i= i= i i = n i i

63 Analyzing Floyd s buildheap algorithm Lessons learned: Most of the nodes near leaves (almost of nodes are leaves!) So design an algorithm that does less work closer to bottom

64 Analyzing Floyd s buildheap algorithm Lessons learned: Most of the nodes near leaves (almost of nodes are leaves!) So design an algorithm that does less work closer to bottom More careful analysis can reveal tighter bounds

65 Analyzing Floyd s buildheap algorithm Lessons learned: Most of the nodes near leaves (almost of nodes are leaves!) So design an algorithm that does less work closer to bottom More careful analysis can reveal tighter bounds Strategy: rather then trying to show a b directly, it can sometimes be simpler to show a t then t b. (Similar to what we did when finding c and n 0 questions when doing asymptotic analysis!)

66 Analyzing Floyd s buildheap algorithm What we re skipping How do we merge two heaps together? 9

67 Analyzing Floyd s buildheap algorithm What we re skipping How do we merge two heaps together? Other kinds of heaps (leftist heaps, skew heaps, binomial queues) 9

68 On to sorting And now on to sorting... 0

69 Why study sorting? Why not just use Collections.sort(...)?

70 Why study sorting? Why not just use Collections.sort(...)? You should just use Collections.sort(...)

71 Why study sorting? Why not just use Collections.sort(...)? You should just use Collections.sort(...) A vehicle for talking about a technique called divide-and-conquer

72 Why study sorting? Why not just use Collections.sort(...)? You should just use Collections.sort(...) A vehicle for talking about a technique called divide-and-conquer Different sorts have different purposes/tradeoffs. (General purpose sorts work well most of the time, but you might need something more efficient in niche cases)

73 Why study sorting? Why not just use Collections.sort(...)? You should just use Collections.sort(...) A vehicle for talking about a technique called divide-and-conquer Different sorts have different purposes/tradeoffs. (General purpose sorts work well most of the time, but you might need something more efficient in niche cases) It s a thing everybody knows.

74 Types of sorts Two different kinds of sorts: Comparison sorts Works by comparing two elements at a time. Assumes elements in list form a consistent, total ordering:

75 Types of sorts Two different kinds of sorts: Comparison sorts Works by comparing two elements at a time. Assumes elements in list form a consistent, total ordering: Formally: for every element a, b, and c in the list, the following must be true. If a b and b a then a = b If a b and b c then a c Either a b is true, or b a is true (or both)

76 Types of sorts Two different kinds of sorts: Comparison sorts Works by comparing two elements at a time. Assumes elements in list form a consistent, total ordering: Formally: for every element a, b, and c in the list, the following must be true. If a b and b a then a = b If a b and b c then a c Either a b is true, or b a is true (or both) Less formally: the compareto(...) method can t be broken.

77 Types of sorts Two different kinds of sorts: Comparison sorts Works by comparing two elements at a time. Assumes elements in list form a consistent, total ordering: Formally: for every element a, b, and c in the list, the following must be true. If a b and b a then a = b If a b and b c then a c Either a b is true, or b a is true (or both) Less formally: the compareto(...) method can t be broken. Fact: comparison sorts will run in O (n log(n)) time at best.

78 Types of sorts Two different kinds of sorts: Niche sorts (aka linear sorts ) Exploits certain properties about the items in the list to reach faster runtimes (typically, O (n) time).

79 Types of sorts Two different kinds of sorts: Niche sorts (aka linear sorts ) Exploits certain properties about the items in the list to reach faster runtimes (typically, O (n) time). Faster, but less general-purpose.

80 Types of sorts Two different kinds of sorts: Niche sorts (aka linear sorts ) Exploits certain properties about the items in the list to reach faster runtimes (typically, O (n) time). Faster, but less general-purpose. We ll focus on comparison sorts, will cover a few linear sorts if time.

81 More definitions In-place sort A sorting algorithm is in-place if it requires only O() extra space to sort the array. Usually modifies input array Can be useful: lets us minimize memory 4

82 More definitions Stable sort A sorting algorithm is stable if any equal items remain in the same relative order before and after the sort. Observation: We sometimes want to sort on some, but not all attribute of an item Items that compare the same might not be exact duplicates Sometimes useful to sort on one attribute first, then another

83 Stable sort: Example Input: Array: [(, "fox"), (9, "dog"), (4, "wolf"), (, "cow")] Compare function: compare pairs by number only

84 Stable sort: Example Input: Array: [(, "fox"), (9, "dog"), (4, "wolf"), (, "cow")] Compare function: compare pairs by number only Output; stable sort: [(4, "wolf"), (, "fox"), (, "cow"), (9, "dog")]

85 Stable sort: Example Input: Array: [(, "fox"), (9, "dog"), (4, "wolf"), (, "cow")] Compare function: compare pairs by number only Output; stable sort: Output; unstable sort: [(4, "wolf"), (, "fox"), (, "cow"), (9, "dog")] [(4, "wolf"), (, "cow"), (, "fox"), (9, "dog")]

86 Overview of sorting algorithms There are many sorts... Quicksort, Merge sort, In-place merge sort, Heap sort, Insertion sort, Intro sort, Selection sort, Timsort, Cubesort, Shell sort, Bubble sort, Binary tree sort, Cycle sort, Library sort, Patience sorting, Smoothsort, Strand sort, Tournament sort, Cocktail sort, Comb sort, Gnome sort, Block sort, Stackoverflow sort, Odd-even sort, Pigeonhole sort, Bucket sort, Counting sort, Radix sort, Spreadsort, Burstsort, Flashsort, Postman sort, Bead sort, Simple pancake sort, Spaghetti sort, Sorting network, Bitonic sort, Bogosort, Stooge sort, Insertion sort, Slow sort, Rainbow sort...

87 Overview of sorting algorithms There are many sorts... Quicksort, Merge sort, In-place merge sort, Heap sort, Insertion sort, Intro sort, Selection sort, Timsort, Cubesort, Shell sort, Bubble sort, Binary tree sort, Cycle sort, Library sort, Patience sorting, Smoothsort, Strand sort, Tournament sort, Cocktail sort, Comb sort, Gnome sort, Block sort, Stackoverflow sort, Odd-even sort, Pigeonhole sort, Bucket sort, Counting sort, Radix sort, Spreadsort, Burstsort, Flashsort, Postman sort, Bead sort, Simple pancake sort, Spaghetti sort, Sorting network, Bitonic sort, Bogosort, Stooge sort, Insertion sort, Slow sort, Rainbow sort......we ll focus on a few

88 Insertion Sort Current item 4 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Already sorted Unsorted

89 Insertion Sort INSERT current item into sorted region 4 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Already sorted Unsorted

90 Insertion Sort INSERT current item into sorted region 4 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Already sorted Unsorted 4 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[]

91 Insertion Sort a[0] a[] a[] a[] a[4] a[] a[] 4 a[] a[] a[9] a[] Already sorted Unsorted INSERT current item into sorted region a[0] a[] a[] a[] a[4] a[] a[] 4 a[] a[] a[9] a[] a[0] a[] a[] a[] a[4] a[] a[] 4 a[] a[] a[9] a[]

92 Insertion Sort INSERT current item into sorted region 4 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Pseudocode Already sorted for (int i = ; i < n; i++) { // Find index to insert into int newindex = findplace(i); } // Insert and shift nodes over shift(newindex, i); Unsorted Worst case runtime? Best case runtime? Average runtime? Stable? In-place? 9

93 Selection Sort Current item Next smallest 4 9 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Already sorted Unsorted

94 Selection Sort SELECT next min and swap with current 4 9 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Already sorted Unsorted

95 Selection Sort SELECT next min and swap with current 4 9 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Already sorted Unsorted 9 4 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[]

96 Selection Sort SELECT next min and swap with current 4 9 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Already sorted Unsorted 9 4 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] 9 4 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[]

97 Selection Sort SELECT next min and swap with current 4 9 a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Pseudocode Already sorted for (int i = 0; i < n; i++) { // Find next smallest int newindex = findnextmin(i); } // Swap current and next smallest swap(newindex, i); Unsorted Worst case runtime? Best case runtime? Average runtime? Stable? In-place?

98 Heap sort Can we use heaps to help us sort? 4

99 Heap sort Can we use heaps to help us sort? Idea: run buildheap then call removemin n times. 4

100 Heap sort Can we use heaps to help us sort? Idea: run buildheap then call removemin n times. Pseudocode E[] input = buildheap(...); E[] output = new E[n]; for (int i = 0; i < n; i++) { output[i] = removemin(input); } Worst case runtime? Best case runtime? Average runtime? Stable? In-place? 4

101 Heap Sort: In-place version Can we do this in-place?

102 Heap Sort: In-place version Can we do this in-place? Idea: after calling removemin, input array has one new space. Put the removed item there.

103 Heap Sort: In-place version Can we do this in-place? Idea: after calling removemin, input array has one new space. Put the removed item there a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Heap Sorted region

104 Heap Sort: In-place version Can we do this in-place? Idea: after calling removemin, input array has one new space. Put the removed item there a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Heap Sorted region Pseudocode E[] input = buildheap(...); for (int i = 0; i < n; i++) { input[n - i - ] = removemin(input); }

105 Heap Sort: In-place version Complication: when using in-place version, final array is reversed! a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Heap Sorted region

106 Heap Sort: In-place version Complication: when using in-place version, final array is reversed! a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Heap Sorted region Several possible fixes:. Run reverse afterwards (seems wasteful?)

107 Heap Sort: In-place version Complication: when using in-place version, final array is reversed! a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Heap Sorted region Several possible fixes:. Run reverse afterwards (seems wasteful?). Use a max heap

108 Heap Sort: In-place version Complication: when using in-place version, final array is reversed! a[0] a[] a[] a[] a[4] a[] a[] a[] a[] a[9] a[] Heap Sorted region Several possible fixes:. Run reverse afterwards (seems wasteful?). Use a max heap. Reverse your compare function to emulate a max heap

109 Technique: Divide-and-Conquer Divide-and-conquer is a useful technique for solving many kinds of problems. It consists of the following steps:

110 Technique: Divide-and-Conquer Divide-and-conquer is a useful technique for solving many kinds of problems. It consists of the following steps:. Divide your work up into smaller pieces (recursively)

111 Technique: Divide-and-Conquer Divide-and-conquer is a useful technique for solving many kinds of problems. It consists of the following steps:. Divide your work up into smaller pieces (recursively). Conquer the individual pieces (as base cases)

112 Technique: Divide-and-Conquer Divide-and-conquer is a useful technique for solving many kinds of problems. It consists of the following steps:. Divide your work up into smaller pieces (recursively). Conquer the individual pieces (as base cases). Combine the results together (recursively)

113 Technique: Divide-and-Conquer Divide-and-conquer is a useful technique for solving many kinds of problems. It consists of the following steps:. Divide your work up into smaller pieces (recursively). Conquer the individual pieces (as base cases). Combine the results together (recursively) Example template algorithm(input) { if (small enough) { CONQUER, solve, and return input } else { DIVIDE input into multiple pieces RECURSE on each piece COMBINE and return results } }

114 Merge sort: Core pieces Divide: Unsorted 9

115 Merge sort: Core pieces Divide: Split array roughly into half Unsorted Unsorted Unsorted 9

116 Merge sort: Core pieces Divide: Split array roughly into half Unsorted Unsorted Unsorted Conquer: 9

117 Merge sort: Core pieces Divide: Split array roughly into half Unsorted Unsorted Unsorted Conquer: Return array when length 9

118 Merge sort: Core pieces Divide: Split array roughly into half Unsorted Unsorted Unsorted Conquer: Return array when length Combine: Sorted Sorted 9

119 Merge sort: Core pieces Divide: Split array roughly into half Unsorted Unsorted Unsorted Conquer: Return array when length Combine: Combine two sorted arrays using merge Sorted Sorted Sorted 9

120 Merge sort: Summary Core idea: split array in half, sort each half, merge back together. If the array has size 0 or, just return it unchanged. Pseudocode sort(input) { if (input.length < ) { return input; } else { smallerhalf = sort(input[0,..., mid]); largerhalf = sort(input[mid +,...]); return merge(smallerhalf, largerhalf); } } 40

121 Merge sort: Example a[0] a[] a[] a[] a[4] a[] a[] a[] 4

122 Merge sort: Example a[0] a[] a[] a[] a[4] a[] a[] a[] a[0] a[] a[] a[] a[4] a[] a[] a[] 4

123 Merge sort: Example a[0] a[] a[] a[] a[4] a[] a[] a[] a[0] a[] a[] a[] a[4] a[] a[] a[] a[0] a[] a[] a[] a[4] a[] a[] a[] 4

124 Merge sort: Example a[0] a[] a[] a[] a[4] a[] a[] a[] a[0] a[] a[] a[] a[4] a[] a[] a[] a[0] a[] a[] a[] a[4] a[] a[] a[] a[0] a[] a[] a[] a[4] a[] a[] a[] 4

125 Merge sort: Example a[0] a[] a[] a[] a[4] a[] a[] a[] 4

126 Merge sort: Example a[0] a[] a[] a[] a[4] a[] a[] a[] a[0] a[] a[] a[] a[4] a[] a[] a[] 4

127 Merge sort: Example a[0] a[] a[] a[] a[4] a[] a[] a[] a[0] a[] a[] a[] a[4] a[] a[] a[] a[0] a[] a[] a[] a[4] a[] a[] a[] 4

128 Merge sort: Example a[0] a[] a[] a[] a[4] a[] a[] a[] a[0] a[] a[] a[] a[4] a[] a[] a[] a[0] a[] a[] a[] a[4] a[] a[] a[] a[0] a[] a[] a[] a[4] a[] a[] a[] 4

129 Merge sort: Analysis Pseudocode sort(input) { if (input.length < ) { return input; } else { smallerhalf = sort(input[0,..., mid]); largerhalf = sort(input[mid +,...]); return merge(smallerhalf, largerhalf); } } Best case runtime? Worst case runtime? 4

130 Merge sort: Analysis Best and worst case We always subdivide the array in half on each recursive call, and merge takes O (n) time to run. So, the best and worst case runtime is the same: if n T (n) = T (n/) + n otherwise 44

131 Merge sort: Analysis Best and worst case We always subdivide the array in half on each recursive call, and merge takes O (n) time to run. So, the best and worst case runtime is the same: if n T (n) = T (n/) + n otherwise But how do we solve this recurrence? 44

132 Analyzing recurrences, part if n We have: T (n) = T (n/) + n otherwise 4

133 Analyzing recurrences, part if n We have: T (n) = T (n/) + n otherwise Problem: Unfolding technique is a major pain to do 4

134 Analyzing recurrences, part if n We have: T (n) = T (n/) + n otherwise Problem: Unfolding technique is a major pain to do Next time: Two new techniques: Tree method: requires a little work, but more general purpose Master method: very easy, but not as general purpose 4