Announcements. Lilian s office hours rescheduled: Fri 2-4pm HW2 out tomorrow, due Thursday, 7/7. CSE373: Data Structures & Algorithms

Transcription

1 Announcements Lilian s office ours resceduled: Fri 2-4pm HW2 out tomorrow, due Tursday, 7/7 CSE373: Data Structures & Algoritms

2 Deletion in BST Wy migt deletion be arder tan insertion? CSE373: Data Structures & Algoritms

3 Deletion Removing an item disrupts te tree structure Basic idea: find te node to be removed, ten fix te tree so tat it is still a binary searc tree Tree cases: Node as no cildren (leaf) Node as one cild Node as two cildren CSE373: Data Structures & Algoritms

4 Deletion Te Leaf Case delete(7) CSE373: Data Structures & Algoritms

5 Deletion Te One Cild Case delete(5) CSE373: Data Structures & Algoritms

6 Deletion Te Two Cild Case delete(5) Wat can we replace 5 wit? CSE373: Data Structures & Algoritms

7 Deletion Te Two Cild Case Idea: Replace te deleted node wit a value guaranteed to be between te two cild subtrees Options: successor from rigt subtree: findmin(node.rigt) predecessor from left subtree: findmax(node.left) Tese are te easy cases of predecessor/successor Now delete te original node containing successor or predecessor Leaf or one cild case easy cases of delete! CSE373: Data Structures & Algoritms

8 Lazy Deletion Lazy deletion can work well for a BST Simpler Can do real deletions later as a batc Some inserts can just undelete a tree node But Can waste space and slow down find operations Make some operations more complicated: How would you cange findmin and findmax? CSE373: Data Structures & Algoritms

9 BuildTree for BST Let s consider buildtree Insert all, starting from an empty tree Insert keys, 2, 3, 4, 5, 6, 7, 8, 9 into an empty BST If inserted in given order, wat is te tree? Wat big-o runtime for tis kind of sorted input? Is inserting in te reverse order any better? O(n 2 ) Can we do better? 2 3 CSE373: Data Structures & Algoritms

10 BuildTree for BST Insert keys, 2, 3, 4, 5, 6, 7, 8, 9 into an empty BST Wat we if could someow re-arrange tem median first, ten left median, rigt median, etc. 5, 3, 7, 2,, 4, 8, 6, 9 5 Wat tree does tat give us? 3 7 Wat big-o runtime? O(n log n), awesome! 9 CSE373: Data Structures & Algoritms

11 Unbalanced BST Balancing a tree at build time is insufficient, as sequences of operations can eventually transform tat carefully balanced tree into te dreaded list At tat point, everyting is O(n) and nobody is appy find insert delete 2 3 CSE373: Data Structures & Algoritms

12 Balanced BST Observation BST: te sallower te better! For a BST wit n nodes inserted in arbitrary order Average eigt is O(log n) see text for proof Worst case eigt is O(n) Simple cases, suc as inserting in key order, lead to te worst-case scenario Solution: Require a Balance Condition tat. Ensures dept is always O(log n) strong enoug! 2. Is efficient to maintain not too strong! CSE373: Data Structures & Algoritms

13 Potential Balance Conditions. Left and rigt subtrees of te root ave equal number of nodes Too weak! Heigt mismatc example: 2. Left and rigt subtrees of te root ave equal eigt Too weak! Double cain example: CSE373: Data Structures & Algoritms

14 Potential Balance Conditions 3. Left and rigt subtrees of every node ave equal number of nodes Too strong! Only perfect trees (2 n nodes) 4. Left and rigt subtrees of every node ave equal eigt Too strong! Only perfect trees (2 n nodes) CSE373: Data Structures & Algoritms

15 Te AVL Balance Condition Left and rigt subtrees of every node ave eigts differing by at most Definition: balance(node) = eigt(node.left) eigt(node.rigt) AVL property: for every node x, balance(x) Ensures small dept Will prove tis by sowing tat an AVL tree of eigt must ave a number of nodes exponential in Efficient to maintain Using single and double rotations CSE373: Data Structures & Algoritms

16 CSE373: Data Structures & Algoritms Lecture 5: AVL Trees Hunter Zan Tanks to Kevin Quinn CSE373: and Data Structures Dan Grossman & Algoritms for slide materials

17 Te AVL Tree Data Structure Structural properties. Binary tree property 2. Balance property: balance of every node is between - and 8 Result: 5 Worst-case dept is O(log n) Ordering property Same as for BST Definition: balance(node) = eigt(node.left) eigt(node.rigt) 5 CSE373: Data Structures & Algoritms

18 An AVL tree? 6 Heigt = 3 Balance = - 4 Heigt = Balance = 8 Heigt = 2 Balance = - Heigt = 0 Balance = 0 7 Heigt = 0 Balance = Heigt = Balance = 0 Heigt = 0 Balance = 0 Heigt = 0 Balance = 0 CSE373: Data Structures & Algoritms

19 An AVL tree? Heigt = 2 Balance = -2 Heigt = 3 Balance = Heigt = Balance = 6 Heigt = 0 Balance = 0 Heigt = 4 Balance = 2 7 Heigt = 0 Balance = 0 8 Heigt = Balance = 0 Heigt = 0 Balance = 0 2 Heigt = 0 Balance = 0 No! CSE373: Data Structures & Algoritms

20 Te sallowness bound Let S() = te minimum number of nodes in an AVL tree of eigt If we can prove tat S() grows exponentially in, ten a tree wit n nodes as a logaritmic eigt Step : Define S() inductively using AVL property S(-)=0, S(0)=, S()=2 For, S() = +S(-)+S(-2) Step 2: Bound S() Using everybody s favorite: Induction! -2 - CSE373: Data Structures & Algoritms

21 Fibonacci Numbers Sequence of numbers were eac number is te sum of te preceding two numbers: 0,,, 2, 3, 5, 8, F(0) = 0 F() = F(n+) = F(n-) + F(n) Grows exponentially CSE373: Data Structures & Algoritms

22 S() and F() S() F() S() F(+3) S() appears to be equal to F(+3) - CSE373: Data Structures & Algoritms

23 Te proof Remember: ) S(-)=0, S(0)=, S()=2 2) For, S() = +S(-)+S(-2) F( + ) = F( - ) + F() Let P() be S() == F(+3)-. We will prove tis for all >= 0 Base cases: S(0) = F(0 + 3) = 2 = S() = 2 F( + 3) = 3 = 2 Inductive Hypotesis: Assume P(k) for an arbitrary k >. P(k): S(k) == F(k+3)- Inductive Step: S(k+) = S(k-) + S(k) + = [F((k-) + 3) ] + [F(k+3) ] + I.H. = F((k-) + 3) + F(k + 3) simplify = F((k+) + 3) def of F P(k)! P(k+) Conclusion: We ave proven by induction tat P() olds for all >= 0. Te minimum number of nodes in an AVL tree grows exponentially wit respect to te eigt! Terefore, te eigt grows logaritmically w.r.t. te number of nodes in an AVL tree! O(log n )!! CSE373: Data Structures & Algoritms

24 Good news Proof means tat if we ave an AVL tree, ten find is O(log n) Recall logaritms of different bases > differ by only a constant factor But as we insert and delete elements, we need to:. Track balance 2. Detect imbalance 3. Restore balance Is tis AVL tree balanced? How about after insert(30)? CSE373: Data Structures & Algoritms

25 An AVL Tree 0 key 3 value 0 3 eigt cildren Track eigt at all times! CSE373: Data Structures & Algoritms

26 AVL find: Same as BST find AVL tree operations AVL insert: First BST insert, ten ceck balance and potentially fix te AVL tree Four different imbalance cases AVL delete: Te easy way is lazy deletion Oterwise, do te deletion and ten ave several imbalance cases (we will likely skip tis but post slides for tose interested) CSE373: Data Structures & Algoritms

27 Insert: detect potential imbalance. Insert te new node as in a BST (a new leaf) 2. For eac node on te pat from te root to te new leaf, te insertion may (or may not) ave canged te node s eigt 3. So after recursive insertion in a subtree, detect eigt imbalance and perform a rotation to restore balance at tat node Type of rotation will depend on te location of te imbalance (if any) Facts tat an implementation can ignore: Tere must be a deepest element tat is imbalanced after te insert (all descendants still balanced) After rebalancing tis deepest node, every node is balanced So at most one node needs to be rebalanced CSE373: Data Structures & Algoritms

28 Case #: Example Insert(6) Insert(3) Insert() Tird insertion violates balance property appens to be at te root Wat is te only way to fix tis? CSE373: Data Structures & Algoritms

29 Fix: Apply Single Rotation Single rotation: Te basic operation we ll use to rebalance Move cild of unbalanced node into parent position Parent becomes te oter cild (always okay in a BST!) Oter subtrees move in only way BST allows (next slide) AVL Property violated ere Intuition: 3 must become root New parent eigt is now te old parent s eigt before insert 0 CSE373: Data Structures & Algoritms

30 Te example generalized Node imbalanced due to insertion somewere in left-left grandcild tat causes an increasing eigt of 4 possible imbalance causes (oter tree coming) First we did te insertion, wic would make a imbalanced + b a +2 a +2 b + Z +3 Z X Y X Y CSE373: Data Structures & Algoritms

31 Te general left-left case Node imbalanced due to insertion somewere in left-left grandcild of 4 possible imbalance causes (oter tree coming) So we rotate at a,using BST facts: X < b < Y < a < Z a +2 b + X Y +3 b + Z X Y +2 + a Z A single rotation restores balance at te node To same eigt as before insertion, so ancestors now balanced CSE373: Data Structures & Algoritms

32 Anoter example: insert(6) CSE373: Data Structures & Algoritms

33 Anoter example: insert(6) CSE373: Data Structures & Algoritms

34 Te general rigt-rigt case Mirror image to left-left case, so you rotate te oter way Exact same concept, but need different code X a b + + a b +2 + Z Y Z X Y CSE373: Data Structures & Algoritms

35 Two cases to go Unfortunately, single rotations are not enoug for insertions in te left-rigt subtree or te rigt-left subtree Simple example: insert(), insert(6), insert(3) First wrong idea: single rotation like we did for left-left CSE373: Data Structures & Algoritms

36 Two cases to go Unfortunately, single rotations are not enoug for insertions in te left-rigt subtree or te rigt-left subtree Simple example: insert(), insert(6), insert(3) Second wrong idea: single rotation on te cild of te unbalanced node CSE373: Data Structures & Algoritms

37 Sometimes two wrongs make a rigt First idea violated te BST property Second idea didn t fix balance But if we do bot single rotations, starting wit te second, it works! (And not just for tis example.) Double rotation:. Rotate problematic cild and grandcild 2. Ten rotate between self and new cild Intuition: 3 must become root CSE373: Data Structures & Algoritms

38 Te general rigt-left case X +3 a X U +3 a U + c V +2 c b - V +2 b - Z + X + a Rotation : b.left = c.rigt c.rigt = b a.rigt = c Rotation 2: U a.rigt = c.left c.left = a root = c c +2 - V b + Z Z CSE373: Data Structures & Algoritms

39 Comments Like in te left-left and rigt-rigt cases, te eigt of te subtree after rebalancing is te same as before te insert So no ancestor in te tree will need rebalancing Does not ave to be implemented as two rotations; can just do: X +3 a U + c V b - +2 Z X + a U c +2 b - V + Z Easier to remember tan you may tink: ) Move c to grandparent s position 2) Put a, b, X, U, V, and Z in te only legal positions for a BST CSE373: Data Structures & Algoritms

40 Te last case: left-rigt X Mirror image of rigt-left Again, no new concepts, only new code to write +2 b U +3 c a + V - Z X + b U c +2 - V a + Z CSE373: Data Structures & Algoritms

41 Insert, summarized Insert as in a BST Ceck back up pat for imbalance, wic will be of 4 cases: Node s left-left grandcild is too tall (left-left single rotation) Node s left-rigt grandcild is too tall (left-rigt double rotation) Node s rigt-left grandcild is too tall (rigt-left double rotation) Node s rigt-rigt grandcild is too tall (rigt-rigt double rotation) Only one case occurs because tree was balanced before insert After te appropriate single or double rotation, te smallestunbalanced subtree as te same eigt as before te insertion So all ancestors are now balanced CSE373: Data Structures & Algoritms

42 Now efficiency Worst-case complexity of find: O(log n) Tree is balanced Worst-case complexity of insert: O(log n) Tree starts balanced A rotation is O() and tere s an O(log n) pat to root (Same complexity even witout one-rotation-is-enoug fact) Tree ends balanced Worst-case complexity of buildtree: O(n log n) Takes some more rotation action to andle delete CSE373: Data Structures & Algoritms

43 Pros and Cons of AVL Trees Arguments for AVL trees:. All operations logaritmic worst-case because trees are always balanced 2. Heigt balancing adds no more tan a constant factor to te speed of insert and delete Arguments against AVL trees:. Difficult to program & debug [but done once in a library!] 2. More space for eigt field 3. Asymptotically faster but rebalancing takes a little time 4. Most large searces are done in database-like systems on disk and use oter structures (e.g., B-trees, a data structure in te text) 5. If amortized (later, I promise) logaritmic time is enoug, use splay trees (also in text) CSE373: Data Structures & Algoritms