1 Copyright 2012 by Pearson Education, Inc. All Rights Reserved.

Transcription

1 CHAPTER 20 AVL Trees Objectives To know wat an AVL tree is ( 20.1). To understand ow to rebalance a tree using te LL rotation, LR rotation, RR rotation, and RL rotation ( 20.2). To know ow to design te AVLTree class ( 20.3). To insert elements into an AVL tree ( 20.4). To implement node rebalancing ( 20.5). To delete elements from an AVL tree ( 20.6). To implement te AVLTree class ( 20.7). To test te AVLTree class ( 20.8). To analyze te complexity of searc, insert, and delete operations in AVL trees ( 20.9). 1

2 20.1 Introduction Key Point: AVL Tree is a balanced binary searc tree. Capter 19 introduced binary searc trees. Te searc, insertion, and deletion time for a binary tree depend on te eigt of te tree. In te worst case, te eigt is O (n). If a tree is perfectly balanced i.e., a complete binary tree its eigt is log n. Can we maintain a perfectly balanced tree? Yes. But doing so will be costly. Te compromise is to maintain a well-balanced tree i.e., te eigts of two subtrees for every node are about te same. AVL trees are well balanced. AVL trees were invented in 1962 by two Russian computer scientists G. M. Adelson-Velsky and E. M. Landis. In an AVL tree, te difference between te eigts of two subtrees for every node is 0 or 1. It can be sown tat te maximum eigt of an AVL tree is O (logn). Te process for inserting or deleting an element in an AVL tree is te same as in a regular binary searc tree. Te difference is tat you may ave to rebalance te tree after an insertion or deletion operation. Te balance factor of a node is te eigt of its rigt subtree minus te eigt of its left subtree. A node is said to be balanced if its balance factor is -1, 0, or 1. A node is said to be left-eavy if its balance factor is -1. A node is said to be rigt-eavy if its balance factor is +1. Pedagogical NOTE Run from l to see ow an AVL tree works, as sown in Figure

3 Figure 20.1 Te animation tool enables you to insert, delete, and searc elements visually Rebalancing Trees Key Point: After inserting or deleting an element from an AVL tree, if te tree becomes unbalanced, perform a rotation operation to rebalance te tree. If a node is not balanced after an insertion or deletion operation, you need to rebalance it. Te process of rebalancing a node is called a rotation. Tere are four possible rotations. LL Rotation: An LL imbalance occurs at a node A suc tat A as a balance factor -2 and a left cild B wit a balance factor -1 or 0, as sown in Figure 20.2a. Tis type of imbalance can be fixed by performing a single rigt rotation at A, as sown in Figure 20.2b. 3

4 A -2 0 or 1 B -1 or 0 B A 0 or -1 T3 +1 T1 +1 T1 T2 T2 T3 T2 s eigt is or +1 (a) (b) Figure 20.2 LL rotation fixes LL imbalance. RR Rotation: An RR imbalance occurs at a node A suc tat A as a balance factor +2 and a rigt cild B wit a balance factor +1 or 0, as sown in Figure 20.3a. Tis type of imbalance can be fixed by performing a single left rotation at A, as sown in Figure 20.3b. A +2 B 0 or -1 T3 B +1 or 0 0 or +1 A T1 +1 T2 s eigt is or +1 T2 T1 +1 T3 T2 (a) (b) Figure 20.3 RR rotation fixes RR imbalance. 4

5 LR Rotation: An LR imbalance occurs at a node A suc tat A as a balance factor -2 and a left cild B wit a balance factor +1, as sown in Figure 20.4a. Assume B s rigt cild is C. Tis type of imbalance can be fixed by performing a double rotation at A (first a single left rotation at B and ten a single rigt rotation at A), as sown in Figure 20.4b. A -2 C 0 +1 B 0 or -1 B A 0 or 1 T4 T1 C -1, 0, or 1 T1 T2 T3 T4 T2 T3 T2 and T3 may ave different eigt, but at least one must ave eigt of. (a) (b) Figure 20.4 LR rotation fixes LR imbalance. RL Rotation: An RL imbalance occurs at a node A suc tat A as a balance factor +2 and a rigt cild B wit a balance factor -1, as sown in Figure 20.5a. Assume B s left cild is C. Tis type of imbalance can be fixed by performing a double rotation at A (first a single rigt rotation at B and ten a single left rotation at A), as sown in Figure 20.5b. A +2 C 0 T1-1 B 0 or -1 A B 0 or 1 0, -1, or 1 C T4 T1 T2 T3 T4 T2 T3 T2 and T3 may ave different eigt, but at leas t one m ust ave eigt of. (a) (b) 5

6 Figure 20.5 RL rotation fixes RL imbalance. Ceck point 20.1 Wat is an AVL tree? Describe te following terms: balance factor, left-eavy, and rigt-eavy Sow te balance factor of eac node in te tree, as sown in Figure (a) (b) Figure 20.6 A balance factor determines weter a node is balanced Describe LL rotation, RR rotation, LR rotation, and RL rotation for an AVL tree For te AVL tree in Figure 20.6a, sow te new AVL tree after adding element 89. Wat rotation did you perform in order to rebalance te tree? Wic node was unbalanced? 20.5 For te AVL tree in Figure 20.6a, sow te new AVL tree after adding element 40. Wat rotation did you perform in order to rebalance te tree? Wic node was unbalanced? 6

7 20.6 For te AVL tree in Figure 20.6a, sow te new AVL tree after adding element 40. Wat rotation did you perform in order to rebalance te tree? Wic node was unbalanced? 20.7 For te AVL tree in Figure 20.6a, sow te new AVL tree after adding element 40. Wat rotation did you perform in order to rebalance te tree? Wic node was unbalanced? 20.8 For te AVL tree in Figure 20.6a, sow te new AVL tree after adding element 47. Wat rotation did you perform in order to rebalance te tree? Wic node was unbalanced? 20.9 For te AVL tree in Figure 20.6a, sow te new AVL tree after adding element 81. Wat rotation did you perform in order to rebalance te tree? Wic node was unbalanced? For te AVL tree in Figure 20.6b, sow te new AVL tree after adding element 200. Wat rotation did you perform in order to rebalance te tree? Wic node was unbalanced? 20.3 Designing Classes for AVL Trees Key Point: Since an AVL tree is a binary searc tree, AVLTree is designed as a subclass of BST. An AVL tree is a binary tree. So you can define te AVLTree class to extend te BST class, as sown in Figure Te BST and TreeNode classes are defined in An AVL tree is a binary tree. So, you can define te AVLTree class to extend te BST class, as sown in Figure Te BST and TreeNode classes are defined in

8 TreeNode BST AVLTreeNode m 0 AVLTree e igt: int Link 1 AVLTree() createnewnode(): AVLTreeNode insert(e: object): bool delete(e: object): bool updateheigt(node: AVLTreeNode): None balancepat(e: object): None balancefactor(node: AVLTreeNode): int balancell(a: TreeNode, parentofa: TreeNode): None balancelr(a: TreeNode, parentofa: TreeNode): None balancerr(a: TreeNode, parentofa: TreeNode): None balancerl(a: TreeNode, parentofa: TreeNode): None Creates an empty AVL tree. Override tis metod to create an AVLTreeNode. Returns true if te element is added successfully. Returns true if te element is removed from te tree successfully. Resets te eigt of te specified node. Balances te nodes in te pat from te node for t e elem ent t o te root i f needed. Returns te balance factor of te node. Performs LL balance. Performs LR balance. Performs RR balance. Performs RL balance. Figure 20.7 Te AVLTree class extends BST wit new implementations for te insert and delete metods. In order to balance te tree, you need to know eac node s eigt. For convenience, store te eigt of eac node in AVLTreeNode and define AVLTreeNode to be a subclass of BianryTree.TreeNode. Note tat TreeNode is defined as a static inner class in BST. AVLTreeNode will be defined as a static inner class. TreeNode contains te data fields element, left, and rigt, wic are inerited in AVLTreeNode. So, AVLTreeNode contains four data fields, as pictured in Figure node: AVLTreeNode element: E eigt: int left: TreeNode<E> rigt: TreeNode<E> Figure 20.8 An AVLTreeNode contains protected data fields element, eigt, left, and rigt. 8

9 In te BST class, te createnewnode() metod creates a TreeNode object. Tis metod is overridden in te AVLTree class to create an AVLTreeNode. Note tat te return type of te createnewnode() metod in te BianryTree class is TreeNode, but te return type of te createnewnode() metod in AVLTree class is AVLTreeNode. Tis is fine, since AVLTreeNode is a subtype of TreeNode. Searcing an element in an AVLTree is te same as searcing in a regular binary tree. So, te searc metod defined in te BST class also works for AVLTree. Te insert and delete metods are overridden to insert and delete an element and perform rebalancing operations if necessary to ensure tat te tree is balanced Overriding te insert Metod Key Point: Inserting an element into an AVL tree is te same as inserting it to a BST, except tat te tree may need to be rebalanced. A new element is always inserted as a leaf node. Te eigts of te ancestors of te new leaf node may increase, as a result of adding a new node. After insertion, ceck te nodes along te pat from te new leaf node up to te root. If a node is found unbalanced, perform an appropriate rotation using te following algoritm in Listing Listing 20.1 Balancing Nodes on a Pat balancepat(e): Get te pat from te node tat contains element e to te root, as illustrated in Figure 20.9 for eac node A in te pat leading to te root { Update te eigt of A Let parentofa denote te parent of A, wic is te next node in te pat, or None if A is te root if balancefactor(a) == -2: if balancefactor(a.left) == -1 or 0: Perform LL rotation # See Figure 20.2 else: Perform LR rotation # See Figure 20.4 else balancefactor(a) == +2: if balancefactor(a.rigt) == +1 or 0: 9

10 Perform RR rotation # See Figure 20.3 else: Perform RL rotation # See Figure 20.5 root A parentofa Figure 20.9 New node contains element o Te nodes along te pat from te new leaf node may become unbalanced. Te algoritm considers eac node in te pat from te new leaf node to te root. Update te eigt of te node on te pat. If a node is balanced, no action is needed. If a node is not balanced, perform an appropriate rotation Implementing Rotations Key Point: An unbalanced tree becomes balanced by performing an appropriate rotation operation. Section 20.2, Rebalancing Tree, illustrated ow to perform rotations at a node. Listing 20.2 gives te algoritm for te LL rotation, as pictured in Figure Listing 20.2 LL Rotation Algoritm balancell(a, parentofa): Let B be te left cild of A. if A is te root: Let B be te new root else: if A is a left cild of parentofa: Let B be a left cild of parentofa else: Let B be a rigt cild of parentofa 10

11 Make T2 te left subtree of A by assigning B.rigt to A.left Make A te left cild of B by assigning A to B.rigt Update te eigt of node A and node B Note tat te eigt of nodes A and B may be canged, but te eigts of oter nodes in te tree are not canged. Similarly, you can implement te RR rotation, LR rotation, and RL rotation Implementing te delete Metod Key Point: Deleting an element from an AVL tree is te same as deleing it from a BST, except tat te tree may need to be rebalanced. As discussed in Section 20.3, Deleting Elements in a BST, to delete an element from a binary tree, te algoritm first locates te node tat contains te element. Let current point to te node tat contains te element in te binary tree and parent point to te parent of te current node. Te current node may be a left cild or a rigt cild of te parent node. Tree cases arise wen deleting an element: Case 1: Te current node does not ave a left cild, as sown in Figure 20.10a. To delete te current node, simply connect te parent wit te rigt cild of te current node, as sown in Figure 20.10b. Te eigt of te nodes along te pat from te parent up to te root may ave decreased. To ensure te tree is balanced, invoke balancepat(parent.element) # Defined in Listing 20.1 Case 2: Te current node as a left cild. Let rigtmost point to te node tat contains te largest element in te left subtree of te current node and parentofrigtmost point to te parent node of te rigtmost node, as sown in Figure 20.12a. Te rigtmost node cannot ave a rigt cild but may ave a left cild. Replace te element value in te current node wit te one in te rigtmost node, connect te parentofrigtmost node wit te left cild of te rigtmost node, and delete te rigtmost node, as sown in Figure 20.12b. 11

12 Te eigt of te nodes along te pat from parentofrigtmost up to te root may ave decreased. To ensure tat te tree is balanced, invoke balancepat(parentofrigtmost) # Defined in Listing Te AVLTree Class Key Point: Te AVLTree class extends te BST class to override te insert and delete metods to rebalance te tree if necessary. Listing 20.3 gives te complete source code for te AVLTree class. Listing 20.3 AVLTree.py 1 from BST import BST 2 from BST import TreeNode 3 4 class AVLTree(BST): 5 def init (self): 6 BST. init (self) 7 8 # Override te createnewnode metod to create an AVLTreeNode 9 def createnewnode(self, e): 10 return AVLTreeNode(e) # Override te insert metod to balance te tree if necessary 13 def insert(self, o): 14 successful = BST.insert(self, o) 15 if not successful: 16 return False # o is already in te tree 17 else: 18 self.balancepat(o) # Balance from o to te root if necessary return True # o is inserted # Update te eigt of a specified node 23 def updateheigt(self, node): 24 if node.left == None and node.rigt == None: # node is a leaf 25 node.eigt = 0 26 elif node.left == None: # node as no left subtree 27 node.eigt = 1 + (node.rigt).eigt 28 elif node.rigt == None: # node as no rigt subtree 29 node.eigt = 1 + (node.left).eigt 30 else: 31 node.eigt = 1 + max((node.rigt).eigt, (node.left).eigt) # Balance te nodes in te pat from te specified 34 # node to te root if necessary 35 def balancepat(self, o): 36 pat = BST.pat(self, o); 37 for i in range(len(pat) - 1, -1, -1): 38 A = pat[i] 39 self.updateheigt(a) 40 parentofa = None if (A == self.root) else pat[i - 1] if self.balancefactor(a) == -2: 12

13 43 if self.balancefactor(a.left) <= 0: 44 self.balancell(a, parentofa) # Perform LL rotation 45 else: 46 self.balancelr(a, parentofa) # Perform LR rotation 47 elif self.balancefactor(a) == +2: 48 if self.balancefactor(a.rigt) >= 0: 49 self.balancerr(a, parentofa) # Perform RR rotation 50 else: 51 self.balancerl(a, parentofa) # Perform RL rotation # Return te balance factor of te node 54 def balancefactor(self, node): 55 if node.rigt == None: # node as no rigt subtree 56 return -node.eigt 57 elif node.left == None: # node as no left subtree 58 return +node.eigt 59 else: 60 return (node.rigt).eigt - (node.left).eigt # Balance LL (see Figure 14.2) 63 def balancell(self, A, parentofa): 64 B = A.left # A is left-eavy and B is left-eavy if A == self.root: 67 self.root = B 68 else: 69 if parentofa.left == A: 70 parentofa.left = B 71 else: 72 parentofa.rigt = B A.left = B.rigt # Make T2 te left subtree of A 75 B.rigt = A # Make A te left cild of B 76 self.updateheigt(a) 77 self.updateheigt(b) # Balance LR (see Figure 14.2(c)) 80 def balancelr(self, A, parentofa): 81 B = A.left # A is left-eavy 82 C = B.rigt # B is rigt-eavy if A == self.root: 85 self.root = C 86 else: 87 if parentofa.left == A: 88 parentofa.left = C 89 else: 90 parentofa.rigt = C A.left = C.rigt # Make T3 te left subtree of A 93 B.rigt = C.left # Make T2 te rigt subtree of B 94 C.left = B 95 C.rigt = A # Adjust eigts 98 self.updateheigt(a) 99 self.updateheigt(b) 100 self.updateheigt(c) # Balance RR (see Figure 14.2(b)) 103 def balancerr(self, A, parentofa): 104 B = A.rigt # A is rigt-eavy and B is rigt-eavy if A == self.root: 107 self.root = B 108 else: 13

14 109 if parentofa.left == A: 110 parentofa.left = B 111 else: 112 parentofa.rigt = B A.rigt = B.left # Make T2 te rigt subtree of A 115 B.left = A 116 self.updateheigt(a) 117 self.updateheigt(b) # Balance RL (see Figure 14.2(d)) 120 def balancerl(self, A, parentofa): 121 B = A.rigt # A is rigt-eavy 122 C = B.left # B is left-eavy if A == self.root: 125 self.root = C 126 else: 127 if parentofa.left == A: 128 parentofa.left = C 129 else: 130 parentofa.rigt = C A.rigt = C.left # Make T2 te rigt subtree of A 133 B.left = C.rigt # Make T3 te left subtree of B 134 C.left = A 135 C.rigt = B # Adjust eigts 138 self.updateheigt(a) 139 self.updateheigt(b) 140 self.updateheigt(c) # Delete an element from te binary tree. 143 # Return True if te element is deleted successfully 144 # Return False if te element is not in te tree 145 def delete(self, element): 146 if self.root == None: 147 return False # Element is not in te tree # Locate te node to be deleted and also locate its parent node 150 parent = None 151 current = self.root 152 wile current!= None: 153 if element < current.element: 154 parent = current 155 current = current.left 156 elif element > current.element: 157 parent = current 158 current = current.rigt 159 else: 160 break # Element is in te tree pointed by current if current == None: 163 return False # Element is not in te tree # Case 1: current as no left cildren (See Figure 23.6) 166 if current.left == None: 167 # Connect te parent wit te rigt cild of te current node 168 if parent == None: 169 root = current.rigt 170 else: 171 if element < parent.element: 172 parent.left = current.rigt 173 else: 174 parent.rigt = current.rigt 14

15 # Balance te tree if necessary 177 self.balancepat(parent.element) 178 else: 179 # Case 2: Te current node as a left cild 180 # Locate te rigtmost node in te left subtree of 181 # te current node and also its parent 182 parentofrigtmost = current 183 rigtmost = current.left wile rigtmost.rigt!= None: 186 parentofrigtmost = rigtmost 187 rigtmost = rigtmost.rigt # Keep going to te rigt # Replace te element in current by te element in rigtmost 190 current.element = rigtmost.element # Eliminate rigtmost node 193 if parentofrigtmost.rigt == rigtmost: 194 parentofrigtmost.rigt = rigtmost.left 195 else: 196 # Special case: parentofrigtmost is current 197 parentofrigtmost.left = rigtmost.left # Balance te tree if necessary 200 self.balancepat(parentofrigtmost.element) self.size -= 1 # One element deleted 203 return True # Element inserted # AVLTreeNode is TreeNode plus eigt 206 class AVLTreeNode(TreeNode): 207 def init (self, e): 208 self.eigt = 0 # New data field 209 TreeNode. init (self, e) Te AVLTree class extends BST (line 4). Its constructor invokes its superclass s constructor to initialize root and size property of a binary tree (line 6). Te createnewnode() metod defined in te BST class creates a TreeNode. Tis metod is overridden to return an AVLTreeNode (lines 9 10). Tis is a variation of te Factory Metod Pattern. Design Pattern: Factory Metod Pattern Te Factory Metod pattern defines an abstract metod for creating an object, but lets subclasses decide wic class to instantiate. Factory Metod lets a class defer instantiation to subclasses. Te insert metod in AVLTree is overridden in lines Te metod first invokes te insert metod in BST, ten invokes balancepat(o) (line 18) to ensure tat te tree is balanced. 15

16 Te balancepat metod first gets te nodes on te pat from te node tat contains element o to te root (line 36). For eac node in te pat, update its eigt (line 39), ceck its balance factor (line 42), and perform appropriate rotations if necessary (lines 42 51). Four metods for performing rotations are defined in lines Eac metod is invoked wit two TreeNode arguments A and parentofa to perform an appropriate rotation at node A. How eac rotation is performed is pictured in Figures After te rotation, te eigts of nodes A, B, and C are updated for te LL and RR rotations (lines 76, 98, 116, 138). Te delete metod in AVLTree is overridden in lines Te metod is te same as te one implemented in te BST class, except tat you ave to rebalance te nodes after deletion in two cases (lines 177, 200) Testing te AVLTree Class Key Point: Tis section gives an example of using te AVLTree class. Listing 20.4 gives a test program. Te program creates an AVLTree initialized wit an array of integers 25, 20, and 5 (lines 6 7), inserts elements in lines 11 20, and deletes elements in lines Listing 20.4 TestAVLTree.py from AVLTree import AVLTree def main(): tree = AVLTree() tree.insert(25) tree.insert(20) tree.insert(5) print("after inserting 25, 20, 5:") printtree(tree) tree.insert(34) tree.insert(50) print("after inserting 34, 50:") printtree(tree) 16

17 tree.insert(30) print("after inserting 30") printtree(tree) tree.insert(10) print("after inserting 10") printtree(tree) tree.delete(34) tree.delete(30) tree.delete(50) print("after removing 34, 30, 50:") printtree(tree) tree.delete(5) print("after removing 5:") printtree(tree) def printtree(tree): # Traverse tree print("inorder (sorted): ", end = "") tree.inorder() print("\npostorder: ", end = "") tree.postorder() print("\npreorder: ", end = "") tree.preorder() print("\nte number of nodes is " + str(tree.getsize())) print() main() # Call te main function Sample output After inserting 25, 20, 5: Inorder (sorted): Postorder: Preorder: Te number of nodes is 3 After inserting 34, 50: Inorder (sorted): Postorder: Preorder: Te number of nodes is 5 After inserting 30 Inorder (sorted): Postorder: Preorder: Te number of nodes is 6 After inserting 10 Inorder (sorted): Postorder: Preorder: Te number of nodes is 7 After removing 34, 30, 50: 17

18 Inorder (sorted): Postorder: Preorder: Te number of nodes is 4 After removing 5: Inorder (sorted): Postorder: Preorder: Te number of nodes is 3 Figure sows ow te tree evolves as elements are added to te tree. After 25 and 20 are added, te tree is as sown in Figure 20.10a. 5 is inserted as a left cild of 20, as sown in Figure 20.10b. Te tree is not balanced. It is left-eavy at node 25. Perform an LL rotation to result an AVL tree, as sown in Figure 20.10c. After inserting 34, te tree is sown in Figure 20.10d. After inserting 50, te tree is as sown in Figure 20.10e. Te tree is not balanced. It is rigt-eavy at node 25. Perform an RR rotation to result in an AVL tree, as sown in Figure 20.10f. After inserting 30, te tree is as sown in Figure 20.10g. Te tree is not balanced. Perform an LR rotation to result in an AVL tree, as sown in Figure After inserting 10, te tree is as sown in Figure 20.10i. Te tree is not balanced. Perform an RL rotation to result in an AVL tree, as sown in Figure 20.10j. 25 Need LL rotation at node (a) Insert 25, 20 (b) Insert 5 (c) Balacned (d) Insert 34 18

19 20 Need RR rotation at node RL rotation at node (e) Insert 50 (f) Balanced (g) Insert LR rotation at node () Balanced (i) Insert 10 (j) Balanced Figure Te tree evolves as new elements are inserted. Figure sows ow te tree evolves as elements are deleted. After deleting 34, 30, and 50, te tree is as sown in Figure 20.11b. Te tree is not balanced. Perform an LL rotation to result an AVL tree, as sown in Figure 20.11c. After deleting 5, te tree is as sown in Figure 20.11d. Te tree is not balanced. Perform an RL rotation to result in an AVL tree, as sown in Figure 20.11e. 19

20 LL rotation at node (a) Delete 34, 30, 50 (b) After 34, 30, 50 are deleted (c) Balanced RL rotation at (d) After 5 is deleted (e) Balanced Figure Te tree evolves as te elements are deleted from te tree Maximum Heigt of an AVL Tree Key Point: Since te eigt of an AVL tree is O(log n), te time complexity of te searc, insert, and delete metods in AVLTree is O(log n). Te time complexity of te searc, insert, and delete metods in AVLTree depends on te eigt of te tree. We can prove tat te eigt of te tree is O (logn). Let G () denote te minimum number of te nodes in an AVL tree wit eigt. Obviously, (1) and G (2) is 2. Te minimum number of nodes in an AVL tree wit eigt 3 minimum subtrees: one wit eigt 1 and te oter wit eigt 2 G ( ) G( 1) G( 2) 1 must ave two. So, G is 1 20

21 Recall tat a Fibonacci number at index i can be described using te recurrence relation F ( i) F( i 1) F( i 2). So, te function G () is essentially te same as F (i) tat log( n 2) were n is te number of nodes in te tree. Terefore, te eigt of an AVL tree is O (logn).. It can be proven Te searc, insert, and delete metods involve only te nodes along a pat in te tree. Te updateheigt and balancefactor metods are executed in a constant time for eac node in te pat. Te balancepat metod is executed in a constant time for a node in te pat. So, te time complexity for te searc, insert, and delete metods is O (logn). Ceck point Wy is te createnewnode metod protected? Wen is te updateheigt metod invoked? Wen is te balancefacotor metod invoked? Wen is te balanacepat metod invoked? Wat are te data fields in te AVLTreeNode class? Wat are data fields in te AVLTree class? In te insert and delete metods, once you ave performed a rotation to balance a node in te tree, is it possible tat tere are still unbalanced nodes? Sow te cange of an AVL tree wen inserting 1, 2, 3, 4, 10, 9, 7, 5, 8, 6 into te tree, in tis order For te tree built in te preceding question, sow its cange after 1, 2, 3, 4, 10, 9, 7, 5, 8, 6 are deleted from te tree in tis order. Key Terms 21

22 AVL tree LL rotation LR rotation RR rotation RL rotation balance factor left-eavy rigt-eavy rotation perfectly balanced well-balanced Capter Summary 1. An AVL tree is a well-balanced binary tree. In an AVL tree, te difference between te eigts of two subtrees for every node is 0 or Te process for inserting or deleting an element in an AVL tree is te same as in a regular binary searc tree. Te difference is tat you may ave to rebalance te tree after an insertion or deletion operation. 3. Imbalances in te tree caused by insertions and deletions are rebalanced troug subtree rotations at te node of te imbalance. 4. Te process of rebalancing a node is called a rotation. Tere are four possible rotations: LL rotation, LR rotation, RR rotation, and RL rotation. 5. Te eigt of an AVL tree is O (logn). So, te time complexities for te searc, insert, and delete metods are O (logn). Multiple-Coice Questions See multiple-coice questions online at liang.armstrong.edu/selftest/selftestpy?capter=20. 22

23 Programming Exercises *20.1 (Displaying AVL tree grapically) Write an applet tat displays an AVL tree along wit its balance factor for eac node (Comparing performance) Write a test program tat randomly generates numbers and inserts tem into a BST, resuffles te numbers and performs searc, and resuffles te numbers again before deleting tem from te tree. Write anoter test program tat does te same ting for an AVLTree. Compare te execution times of tese two programs. **20.3 (Parent reference for BST) Suppose tat te TreeNode class defined in BST contains a reference to te node s parent, as sown in Exercise Implement te AVLTree class to support tis cange. Write a test program tat adds numbers 1, 2,..., 100 to te tree and displays te pats for all leaf nodes. **20.4 (Te kt smallest element) You can find te kt smallest element in a BST in O (n) time from an inorder iterator. For an AVL tree, you can find it in O (log n) time. To acieve tis, add a new data field named size in AVLTreeNode to store te number of nodes in te subtree rooted at tis node. Note tat te size of a node v is one more tan te sum of te sizes of its two cildren. Figure sows an AVL tree and te size value for eac node in te tree. 25 size: 6 20 size: 2 34 size: 3 5 size: 1 30 size: 1 50 size: 1 23

24 Figure Te size data field in AVLTreeNode stores te number of nodes in te subtree rooted at te node. In te AVLTree class, add te following metod to return te kt smallest element in te tree. def find(k) Te metod returns None if k < 1 or k > te size of te tree. Tis metod can be implemented using a recursive metod find(k, root) tat returns te kt smallest element in te tree wit te specified root. Let A and B be te left and rigt cildren of te root, respectively. Assuming tat te tree is not empty and k root. size, find(k, root) can be recursively defined as follows: root.element, if A is null and k is 1; B.element, if A is null and k is 2; find( k, root) f( k, A), if k A.size; root.element, if k A.size 1; f( k- Asize. -1, B), if k A.size 1; Modify te insert and delete metods in AVLTree to set te correct value for te size property in eac node. Te insert and delete metods will still be in O (logn) time. Te find(k) metod can be implemented in O (logn) time. Terefore, you can find te kt smallest element in an AVL tree in O (log n) time. ***20.5 (AVL tree animation) Write a program tat animates te AVL tree insert, delete, and searc metods, as sown in Figure **20.6 (Closest pair of points) Section 23.8 introduced an algoritm for finding a closest pair of points in O ( n log n) time using a divide-and-conquer approac. Te algoritm was implemented 24

25 using recursion wit a lot of overead. Using te plain-sweep approac along wit an AVL tree, you can solve te same problem in O ( n log n) time. Implement te algoritm using an AVLTree. 25