1. COSC 3101A - Design and Analysis of Algorithms 3 Recurrences Master’s Method Heapsort and Priority Queue Many of the slides are taken from Monica Nicolescu’s slides, Univ. Nevada, Reno, monica@cs.unr.edu

2. 5/18/2004 Lecture 3COSC3101A2 Fibonacci numbers F(n) = F(n-1) + F(n-2) F(1) = 0, F(2) = 1 F(3) = 1, F(4) = 2, F(5) = 3, and so on Leonardo Pisano Born: 1170 in (probably) Pisa (now in Italy) Died: 1250 in (possibly) Pisa (now in Italy) “A certain man put a pair of rabbits in a place surrounded on all sides by a wall. How many pairs of rabbits can be produced from that pair in a year if it is supposed that every month each pair begets a new pair which from the second month on becomes productive? “ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55,...

3. 5/18/2004 Lecture 3COSC3101A3 Review: Recursive Algorithms A recursive algorithm is an algorithm which solves a problem by repeatedly reducing the problem to a smaller version of itself.. until it reaches a form for which a solution exists. Compared with iterative algorithms: –More memory –More computation –Simpler, natural way of thinking about the problem

4. 5/18/2004 Lecture 3COSC3101A4 Review: Recursive Example (1) N! (N factorial) is defined for positive values as: N! = 0 if N = 0 N! = N * (N-1) * (N-2) * (N-3) * … * 1 if N > 0 For example: 5! = 5*4*3*2*1 = 120 3! = 3*2*1 = 6 The definition of N! can be restated as: N! = N * (N-1)! Where 0! = 1 This is the same N!, but it is defined by reducing the problem to a smaller version of the original (hence, recursively).

5. 5/18/2004 Lecture 3COSC3101A5 Review: Recursive Example (2) int factorial(int num){ if (num == 0) return 1; else return num * factorial(num – 1); } Assume that factorial is called with the argument 4: Call to factorial(4) will return  4 * value returned by factorial(3) Call to factorial(3) will return  3 * value returned by factorial(2) Call to factorial(2) will return  2 * value returned by factorial(1) Call to factorial(1) will return  1 * value returned by factorial(0) Call to factorial(0) returns  1

6. 5/18/2004 Lecture 3COSC3101A6 Review: Recursive Example (3)

7. 5/18/2004 Lecture 3COSC3101A7 Recurrences Def.: Recurrence = an equation or inequality that describes a function in terms of its value on smaller inputs, and one or more base cases E.g.: Fibonacci numbers: Recurrence: F(n) = F(n-1) + F(n-2) Boundary conditions: F(1) = 0, F(2) = 1 Compute: F(3) = 1, F(4) = 2, F(5) = 3, and so on In many cases, the running time of an algorithm is expressed as a recurrence!

8. 5/18/2004 Lecture 3COSC3101A8 Recurrences and Running Time Recurrences arise when an algorithm contains recursive calls to itself What is the actual running time of the algorithm? Need to solve the recurrence –Find an explicit formula of the expression (the generic term of the sequence)

9. 5/18/2004 Lecture 3COSC3101A9 Typical Recurrences Running Time T(n) = T(n-1) + nΘ(n 2 ) –Recursive algorithm that loops through the input to eliminate one item T(n) = T(n/2) + cΘ(lgn) –Recursive algorithm that halves the input in one step T(n) = T(n/2) + nΘ(n) –Recursive algorithm that halves the input but must examine every item in the input T(n) = 2T(n/2) + 1Θ(n) –Recursive algorithm that splits the input into 2 halves and does a constant amount of other work

10. 5/18/2004 Lecture 3COSC3101A10 Recurrences - Intuition For a recurrence of the type: It takes f(n) to make the processing for the problem of size n The algorithm divides the problem into a subproblems, each of size n/b T(n) = number of subproblems * Running time (n/b) + processing of the problem of size n

11. 5/18/2004 Lecture 3COSC3101A11 Methods for Solving Recurrences Iteration Method Substitution Method Recursion Tree Method Master Method

12. 5/18/2004 Lecture 3COSC3101A12 Iteration Method 1.Expand (iterate) the recurrence 2.Express The function as a summation of terms dependent only on n and the initial condition

13. 5/18/2004 Lecture 3COSC3101A13 Iteration Method – Example(1) T(n) = c + T(n/2) T(n) = c + T(n/2)T(n/2) = c + T(n/4) = c + c + T(n/4)T(n/4) = c + T(n/8) = c + c + c + T(n/8) Assume n = 2 k T(n) = c + c + … + c + T(1) = clgn + T(1) = Θ(lgn) k times

14. 5/18/2004 Lecture 3COSC3101A14 Iteration Method – Example(2) T(n) = n + 2T(n/2) T(n) = n + 2T(n/2) T(n/2) = n/2 + 2T(n/4) = n + 2(n/2 + 2T(n/4)) = n + n + 4T(n/4) = n + n + 4(n/4 + 2T(n/8)) = n + n + n + 8T(n/8) … = in + 2 i T(n/2 i ) = kn + 2 k T(1) = nlgn + nT(1) = Θ(nlgn) Assume: n = 2 k

15. 5/18/2004 Lecture 3COSC3101A15 Substitution method (1) 1.Guess a solution Experiences, creativity iteration method, recursion-tree method 2.Use induction to prove that the solution works

16. 5/18/2004 Lecture 3COSC3101A16 Substitution method (2) Guess a solution – T(n) = O(g(n)) –Induction goal: apply the definition of the asymptotic notation T(n) ≤ c g(n), for some c > 0 and n ≥ n 0 –Induction hypothesis: T(k) ≤ c g(k) for all k ≤ n Prove the induction goal –Use the induction hypothesis to find some values of the constants c and n 0 for which the induction goal holds

17. 5/18/2004 Lecture 3COSC3101A17 Substitution Method – Example 1-1 T(n) = T(n-1) + n Guess: T(n) = O(n 2 ) –Induction goal: T(n) ≤ c n 2, for some c and n ≥ n 0 –Induction hypothesis: T(k) ≤ ck 2 for all k ≤ n Proof of induction goal: T(n) = T(n-1) + n ≤ c (n-1) 2 + n = cn 2 – (2cn – c - n) ≤ cn 2 if: 2cn – c – n ≥ 0  c ≥ n/(2n-1)  c ≥ 1/(2 – 1/n) –For n ≥ 1  2 – 1/n ≥ 1  any c ≥ 1 will work

18. 5/18/2004 Lecture 3COSC3101A18 Substitution Method – Example 1-2 T(n) = T(n-1) + n Boundary conditions: –Base case: n 0 = 1  T(1) = 1 has to verify condition: T(1) ≤ c (1) 2  1 ≤ c  OK! We can similarly prove that T(n) =  (n 2 ) And therefore: T(n) =  (n 2 )

19. 5/18/2004 Lecture 3COSC3101A19 Substitution Method – Example 2-1 T(n) = 2T(n/2) + n Guess: T(n) = O(nlgn) –Induction goal: T(n) ≤ cn lgn, for some c and n ≥ n 0 –Induction hypothesis: T(n/2) ≤ cn lg(n/2) Proof of induction goal: T(n) = T(n/2) + n ≤ 2c (n/2)lg(n/2) + n = cn lgn – cn + n ≤ cn lgn if: - cn + n ≤ 0  c ≥ 1

20. 5/18/2004 Lecture 3COSC3101A20 Substitution Method – Example 2-2 T(n) = 2T(n/2) + n Boundary conditions: –Base case: n 0 = 1  T(1) = 1 has to verify condition: T(1) ≤ cn 0 lgn 0  1 ≤ c * 1 * lg1 = 0 – contradiction –Choose n 0 = 2  T(2) = 4 has to verify condition: T(2) ≤ c * 2 * lg2  4 ≤ 2c  choose c = 2 We can similarly prove that T(n) =  (nlgn) And therefore: T(n) =  (nlgn)

21. 5/18/2004 Lecture 3COSC3101A21 Changing variables –Rename: m = lgn  n = 2 m T ( 2 m ) = 2T(2 m/2 ) + m –Rename: S(m) = T(2 m ) S(m) = 2S(m/2) + m  S(m) = O(mlgm) (demonstrated before) T(n) = T(2 m ) = S(m) = O(mlgm)=O(lgnlglgn) Idea: transform the recurrence to one that you have seen before T(n) = 2T( ) + lgn

22. 5/18/2004 Lecture 3COSC3101A22 Recursion-tree method Convert the recurrence into a tree: 1.Each node represents the cost incurred at various levels of recursion 2.Sum up the costs of all levels Used to “guess” a solution for the recurrence

23. 5/18/2004 Lecture 3COSC3101A23 Recursion-tree Example 1 W(n) = 2W(n/2) + n 2 Subproblem size at level i is: n/2 i Subproblem size hits 1 when 1 = n/2 i  i = lgn Cost of the problem at level i = n 2 /2 i No. of nodes at level i = 2 i Total cost:  W(n) = O(n 2 )

24. 5/18/2004 Lecture 3COSC3101A24 Recursion-tree Example 2 E.g.: T(n) = 3T(n/4) + cn 2 Subproblem size at level i is: n/4 i Subproblem size hits 1 when 1 = n/4 i  i = log 4 n Cost of a node at level i = c( n/4 i ) 2 Number of nodes at level i = 3 i  last level has 3 log 4 n = n log 4 3 nodes Total cost:  T(n) = O(n 2 )

25. 5/18/2004 Lecture 3COSC3101A25 Master method “Cookbook” for solving recurrences of the form: where, a ≥ 1, b > 1, and f(n) > 0 Case 1: if f(n) = O(n log b a -  ) for some  > 0, then: T(n) =  (n t ) Case 2: if f(n) =  (n log b a ), then: T(n) =  (n log b a lgn) Case 3: if f(n) =  (n log b a +  ) for some  > 0, and if af(n/b) ≤ cf(n) for some c < 1 and all sufficiently large n, then: T(n) =  (f(n)) regularity condition

26. 5/18/2004 Lecture 3COSC3101A26 Why n log b a ? Assume n = b k  k = log b n At the end of iteration i = k: Case 1: –If f(n) is dominated by n log b a : T(n) =  (n log b n ) Case 3: –If f(n) dominates n log b a : T(n) =  (f(n)) Case 2: –If f(n) =  (n log b a ) : T(n) =  (n log b a logn)

27. 5/18/2004 Lecture 3COSC3101A27 Examples (1) T(n) = 2T(n/2) + n a = 2, b = 2, log 2 2 = 1 Compare n log 2 2 with f(n) = n  f(n) =  (n)  Case 2  T(n) =  (nlgn)

28. 5/18/2004 Lecture 3COSC3101A28 Examples (2) T(n) = 2T(n/2) + n 2 a = 2, b = 2, log 2 2 = 1 Compare n with f(n) = n 2  f(n) =  (n 1+  ) Case 3  verify regularity cond. a f(n/b) ≤ c f(n)  2 n 2 /4 ≤ c n 2  c = ½ is a solution (c<1)  T(n) =  (n 2 )

29. 5/18/2004 Lecture 3COSC3101A29 Examples (3) T(n) = 2T(n/2) + a = 2, b = 2, log 2 2 = 1 Compare n with f(n) = n 1/2  f(n) = O(n 1-  ) Case 1  T(n) =  (n)

30. 5/18/2004 Lecture 3COSC3101A30 Examples (4) T(n) = 3T(n/4) + nlgn a = 3, b = 4, log 4 3 = 0.793 Compare n 0.793 with f(n) = nlgn f(n) =  (n log 4 3+  ) Case 3 Check regularity condition: 3  (n/4)lg(n/4) ≤ (3/4)nlgn = c  f(n), c=3/4  T(n) =  (nlgn)

31. 5/18/2004 Lecture 3COSC3101A31 Examples (5) T(n) = 2T(n/2) + nlgn a = 2, b = 2, log 2 2 = 1 Compare n with f(n) = nlgn –seems like case 3 should apply f(n) must be polynomially larger by a factor of n  In this case it is only larger by a factor of lgn

32. 5/18/2004 Lecture 3COSC3101A32 A Job Scheduling Application Job scheduling –The key is the priority of the jobs in the queue –The job with the highest priority needs to be executed next Operations –Insert, remove maximum Data structures –Priority queues –Ordered array/list, unordered array/list

33. 5/18/2004 Lecture 3COSC3101A33 Example

34. 5/18/2004 Lecture 3COSC3101A34 PQ Implementations & Cost Worst-case asymptotic costs for a PQ with N items InsertRemove max ordered array ordered list unordered array unordered list N N N N 1 1 1 1 Can we implement both operations efficiently?

35. 5/18/2004 Lecture 3COSC3101A35 Background on Trees Def: Binary tree = structure composed of a finite set of nodes that either: –Contains no nodes, or –Is composed of three disjoint sets of nodes: a root node, a left subtree and a right subtree 2 148 1 16 4 3 910 root Right subtree Left subtree

36. 5/18/2004 Lecture 3COSC3101A36 Special Types of Trees Def: Full binary tree = a binary tree in which each node is either a leaf or has degree exactly 2. Def: Complete binary tree = a binary tree in which all leaves have the same depth and all internal nodes have degree 2. Full binary tree 2 148 1 16 7 4 3 910 12 Complete binary tree 2 1 16 4 3 910

37. 5/18/2004 Lecture 3COSC3101A37 The Heap Data Structure Def: A heap is a nearly complete binary tree with the following two properties: –Structural property: all levels are full, except possibly the last one, which is filled from left to right –Order (heap) property: for any node x Parent(x) ≥ x Heap 5 7 8 4 It doesn’t matter that 4 in level 1 is smaller than 5 in level 2 2

38. 5/18/2004 Lecture 3COSC3101A38 Definitions Height of a node = the number of edges on a longest simple path from the node down to a leaf Depth of a node = the length of a path from the root to the node Height of tree = height of root node =  lgn , for a heap of n elements 2 148 1 16 4 3 910 Height of root = 3 Height of (2)= 1 Depth of (10)= 2

39. 5/18/2004 Lecture 3COSC3101A39 Array Representation of Heaps A heap can be stored as an array A. –Root of tree is A[1] –Left child of A[i] = A[2i] –Right child of A[i] = A[2i + 1] –Parent of A[i] = A[  i/2  ] –Heapsize[A] ≤ length[A] The elements in the subarray A[(  n/2  +1).. n] are leaves The root is the maximum element of the heap A heap is a binary tree that is filled in order

40. 5/18/2004 Lecture 3COSC3101A40 Heap Types Max-heaps (largest element at root), have the max-heap property: –for all nodes i, excluding the root: A[PARENT(i)] ≥ A[i] Min-heaps (smallest element at root), have the min-heap property: –for all nodes i, excluding the root: A[PARENT(i)] ≤ A[i]

41. 5/18/2004 Lecture 3COSC3101A41 Operations on Heaps Maintain the max-heap property –MAX-HEAPIFY Create a max-heap from an unordered array –BUILD-MAX-HEAP Sort an array in place –HEAPSORT Priority queue operations

42. 5/18/2004 Lecture 3COSC3101A42 Operations on Priority Queues Max-priority queues support the following operations: –INSERT (S, x) : inserts element x into set S –EXTRACT-MAX (S) : removes and returns element of S with largest key –MAXIMUM (S) : returns element of S with largest key –INCREASE-KEY (S, x, k) : increases value of element x ’s key to k (Assume k ≥ x ’s current key value)

43. 5/18/2004 Lecture 3COSC3101A43 Maintaining the Heap Property Suppose a node is smaller than a child –Left and Right subtrees of i are max-heaps Invariant: –the heap condition is violated only at that node To eliminate the violation: –Exchange with larger child –Move down the tree –Continue until node is not smaller than children

44. 5/18/2004 Lecture 3COSC3101A44 Maintaining the Heap Property Assumptions: –Left and Right subtrees of i are max-heaps –A[i] may be smaller than its children Alg: MAX-HEAPIFY( A, i, n ) 1.l ← LEFT( i ) 2.r ← RIGHT( i ) 3.if l ≤ n and A[l] > A[i] 4. then largest ← l 5. else largest ← i 6.if r ≤ n and A[r] > A[largest] 7. then largest ← r 8.if largest  i 9. then exchange A[i] ↔ A[largest] 10. MAX-HEAPIFY( A, largest, n )

45. 5/18/2004 Lecture 3COSC3101A45 Example MAX-HEAPIFY(A, 2, 10) A[2] violates the heap property A[2]  A[4] A[4] violates the heap property A[4]  A[9] Heap property restored

46. 5/18/2004 Lecture 3COSC3101A46 MAX-HEAPIFY Running Time Intuitively: –A heap is an almost complete binary tree  must process O(lgn) levels, with constant work at each level Running time of MAX-HEAPIFY is O(lgn) Can be written in terms of the height of the heap, as being O(h) –Since the height of the heap is  lgn 

47. 5/18/2004 Lecture 3COSC3101A47 Building a Heap Alg: BUILD-MAX-HEAP (A) 1.n = length[A] 2. for i ←  n/2  downto 1 3. do MAX-HEAPIFY (A, i, n) Convert an array A[1 … n] into a max-heap ( n = length[A] ) The elements in the subarray A[(  n/2  +1).. n] are leaves Apply MAX-HEAPIFY on elements from 1 to  n/2  2 148 1 16 7 4 3 910 1 23 4567 89 4132169101487 A:

48. 5/18/2004 Lecture 3COSC3101A48 Example: A 4132169101487 2 8 1 16 7 4 3 910 1 23 4567 89 14 28 1 16 7 4 10 93 1 23 4567 89 2 148 1 16 7 4 3 910 1 23 4567 89 14 28 1 16 7 4 3 910 1 23 4567 89 14 28 16 7 1 4 10 93 1 23 4567 89 8 24 14 7 1 16 10 93 1 23 4567 89 i = 5 i = 4 i = 3 i = 2 i = 1

49. 5/18/2004 Lecture 3COSC3101A49 Correctness of BUILD-MAX-HEAP Loop invariant: –At the start of each iteration of the for loop, each node i + 1, i + 2,…, n is the root of a max-heap Initialization: –i =  n/2  : Nodes  n/2  +1,  n/2  +2, …, n are leaves  they are the root of trivial max-heaps 2 148 1 16 7 4 3 910 1 23 4567 89

50. 5/18/2004 Lecture 3COSC3101A50 Correctness of BUILD-MAX-HEAP Maintenance: –MAX-HEAPIFY makes node i a max- heap root and preserves the property that nodes i + 1, i + 2, …, n are roots of max-heaps –Decrementing i in the for loop reestablishes the loop invariant Termination: –i = 0  each node 1, 2, …, n is the root of a max-heap (by the loop invariant) 2 148 1 16 7 4 3 910 1 23 4567 89

51. 5/18/2004 Lecture 3COSC3101A51 Running Time of BUILD-MAX-HEAP  Running time: O(nlgn) This is not an asymptotically tight upper bound Alg: BUILD-MAX-HEAP (A) 1.n = length[A] 2. for i ←  n/2  downto 1 3. do MAX-HEAPIFY (A, i, n) O(lgn) O(n)

52. 5/18/2004 Lecture 3COSC3101A52 Running Time of BUILD-MAX-HEAP HEAPIFY takes O(h)  the cost of HEAPIFY on a node i is proportional to the height of the node i in the tree HeightLevel h 0 = 3 (  lgn  ) h 1 = 2 h 2 = 1 h 3 = 0 i = 0 i = 1 i = 2 i = 3 (  lgn  ) No. of nodes 2020 2121 2 2323 h i = h – i height of the heap rooted at level i n i = 2 i number of nodes at level i

53. 5/18/2004 Lecture 3COSC3101A53 Running Time of BUILD-MAX-HEAP Cost of HEAPIFY at level i  number of nodes at that level Replace the values of n i and h i computed before Multiply by 2 h both at the nominator and denominator and write 2 i as Change variables: k = h - i The sum above is smaller than the sum of all elements to  and h = lgn The sum above is smaller than 2 Running time of BUILD-MAX-HEAP: T(n) = O(n)

54. 5/18/2004 Lecture 3COSC3101A54 Heapsort Goal: –Sort an array using heap representations Idea: –Build a max-heap from the array –Swap the root (the maximum element) with the last element in the array –“Discard” this last node by decreasing the heap size –Call MAX-HEAPIFY on the new root –Repeat this process until only one node remains

55. 5/18/2004 Lecture 3COSC3101A55 Alg: HEAPSORT(A) 1. BUILD-MAX-HEAP (A) 2. for i ← length[A] downto 2 3. do exchange A[1] ↔ A[i] 4. MAX-HEAPIFY (A, 1, i - 1) Running time: O(nlgn) O(n) O(lgn) n-1 times

56. 5/18/2004 Lecture 3COSC3101A56 Example:A=[7, 4, 3, 1, 2] MAX-HEAPIFY(A, 1, 4) MAX-HEAPIFY(A, 1, 3) MAX-HEAPIFY(A, 1, 2) MAX-HEAPIFY(A, 1, 1)

57. 5/18/2004 Lecture 3COSC3101A57 HEAP-MAXIMUM Goal: –Return the largest element of the heap Alg: HEAP-MAXIMUM (A) 1.return A[1] Running time: O(1) Heap A: Heap-Maximum(A) returns 7

58. 5/18/2004 Lecture 3COSC3101A58 HEAP-EXTRACT-MAX Goal: –Extract the largest element of the heap (i.e., return the max value and also remove that element from the heap Idea: –Exchange the root element with the last –Decrease the size of the heap by 1 element –Call MAX-HEAPIFY on the new root, on a heap of size n-1 Heap A: Root is the largest element

59. 5/18/2004 Lecture 3COSC3101A59 HEAP-EXTRACT-MAX Alg: HEAP-EXTRACT-MAX (A, n) 1. if n < 1 2. then error “heap underflow” 3. max ← A[1] 4. A[1] ← A[n] 5. MAX-HEAPIFY (A, 1, n-1) remakes heap 6. return max Running time: O(lgn)

60. 5/18/2004 Lecture 3COSC3101A60 Example: HEAP-EXTRACT-MAX 8 24 14 7 1 16 10 93 max = 16 8 24 14 7 1 10 93 Heap size decreased with 1 4 21 8 7 14 10 93 Call MAX-HEAPIFY (A, 1, n-1)

61. 5/18/2004 Lecture 3COSC3101A61 HEAP-INCREASE-KEY Goal: –Increases the key of an element i in the heap Idea: –Increment the key of A[i] to its new value –If the max-heap property does not hold anymore: traverse a path toward the root to find the proper place for the newly increased key 8 2 4 14 7 1 16 10 93 i Key [i] ← 15

62. 5/18/2004 Lecture 3COSC3101A62 HEAP-INCREASE-KEY Alg: HEAP-INCREASE-KEY (A, i, key) 1. if key < A[i] 2. then error “new key is smaller than current key” 3. A[i] ← key 4. while i > 1 and A[PARENT(i)] < A[i] 5. do exchange A[i] ↔ A[PARENT(i)] 6. i ← PARENT(i) Running time: O(lgn) 8 2 4 14 7 1 16 10 93 i Key [i] ← 15

63. 5/18/2004 Lecture 3COSC3101A63 Example: HEAP-INCREASE-KEY 14 28 15 7 1 16 10 93 i 8 2 4 14 7 1 16 10 93 i Key [ i ] ← 15 8 2 15 14 7 1 16 10 93 i 15 28 14 7 1 16 10 93 i

64. 5/18/2004 Lecture 3COSC3101A64 -- MAX-HEAP-INSERT Goal: –Inserts a new element into a max- heap Idea: –Expand the max-heap with a new element whose key is -  –Calls HEAP-INCREASE-KEY to set the key of the new node to its correct value and maintain the max-heap property 8 24 14 7 1 16 10 93 15 8 24 14 7 1 16 10 93

65. 5/18/2004 Lecture 3COSC3101A65 MAX-HEAP-INSERT Alg: MAX-HEAP-INSERT (A, key, n) 1. heap-size[A] ← n + 1 2. A[n + 1] ← -  3. HEAP-INCREASE-KEY (A, n + 1, key) Running time: O(lgn) -- 8 24 14 7 1 16 10 93

66. 5/18/2004 Lecture 3COSC3101A66 Example: MAX-HEAP-INSERT -- 8 24 14 7 1 16 10 93 Insert value 15: - Start by inserting -  15 8 24 14 7 1 16 10 93 Increase the key to 15 Call HEAP-INCREASE-KEY on A[11] = 15 7 8 24 14 15 1 16 10 93 7 8 24 15 14 1 16 10 93 The restored heap containing the newly added element

67. 5/18/2004 Lecture 3COSC3101A67 Summary We can perform the following operations on heaps: –MAX-HEAPIFY O(lgn) –BUILD-MAX-HEAP O(n) –HEAP-SORT O(nlgn) –MAX-HEAP-INSERT O(lgn) –HEAP-EXTRACT-MAX O(lgn) –HEAP-INCREASE-KEY O(lgn) –HEAP-MAXIMUM O(1)

68. 5/18/2004 Lecture 3COSC3101A68 Readings Chapter 8, 6