AVL Trees. CSE260, Computer Science B: Honors Stony Brook University

Transcription

1 AVL Trees CSE260, Computer Science B: Honors Stony Brook University ttp:// 1

2 Objectives To know wat an AVL tree is To understand ow to rebalance a tree using te LL rotation, LR rotation, RR rotation, and RL rotation To know ow to design te AVLTree class To insert elements into an AVL tree To implement node rebalancing To delete elements from an AVL tree To implement te AVLTree class To test te AVLTree class To analyze te complexity of searc, insert, and delete operations in AVL trees 2

3 Wy AVL Tree? Te searc, insertion, and deletion time for a binary tree is dependent 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 it will be costly to do so Te compromise is to maintain a well-balanced tree, i.e., te eigts of two subtrees for every node are about te same 3

4 Wat is an AVL Tree? AVL trees are well-balanced binary searc trees were invented 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 Te maximum eigt of an AVL tree is O(log n) 4

5 Balance Factor/Left-Heavy/Rigt-Heavy 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 5

6 Balancing Trees 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 LR rotation RR rotation RL rotation 6

7 LL imbalance and LL rotation LL Rotation: An LL imbalance occurs at a node A if A as a balance factor -2 and a left cild B as a balance factor -1 or 0 Tis type of imbalance can be fixed by performing a single rigt rotation at A: 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 7

8 RR imbalance and RR rotation RR Rotation: An RR imbalance occurs at a node A if A as a balance factor +2 and a rigt cild B as a balance factor +1 or 0 Tis type of imbalance can be fixed by performing a single left rotation at A: 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 8

9 LR imbalance and LR rotation LR Rotation: An LR imbalance occurs at a node A if A as a balance factor -2 and a left cild B as a balance factor +1 Assume B s rigt cild is C Tis type of imbalance can be fixed by performing a double rotation: first a single left rotation at B and ten a single rigt rotation at A 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. 9

10 RL imbalance and RL rotation RL Rotation: An RL imbalance occurs at a node A if A as a balance factor +2 and a rigt cild B as a balance factor -1 Assume B s left cild is C Tis type of imbalance can be fixed by performing a double rotation: first a single rigt rotation at B and ten a single left rotation at A 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 10 T2 T3 T2 and T3 may ave different eigt, but at least one' must ave eigt of.

11 11

12 12

13 13

14 Designing Classes for AVL Trees An AVL tree is a binary tree, so we can define te AVLTree class to extend te BST class 14

15 public class AVLTree<E extends Comparable<E>> extends BST<E> { /** Create a default AVL tree */ public AVLTree() { /** Create an AVL tree from an array of objects */ public AVLTree(E[] objects) { super(objects); /** AVLTreeNode is TreeNode plus eigt */ protected static class AVLTreeNode<E extends Comparable<E>> extends BST.TreeNode<E> { protected int eigt = 0; // New data field public AVLTreeNode(E o) { /** Override createnewnode to create an AVLTreeNode */ protected AVLTreeNode<E> createnewnode(e e) { return new AVLTreeNode<E>(e); 15

16 @Override /** Insert an element and rebalance if necessary */ public boolean insert(e e) { boolean successful = super.insert(e); if (!successful) return false; // e is already in te tree else { balancepat(e); // Balance from e to te root if necessary return true; // e is inserted 16

17 /** Update te eigt of a specified node */ private void updateheigt(avltreenode<e> node) { if (node.left == null && node.rigt == null) // node is a leaf node.eigt = 0; else if (node.left == null) // node as no left subtree node.eigt = 1 + ((AVLTreeNode<E>)(node.rigt)).eigt; else if (node.rigt == null) // node as no rigt subtree node.eigt = 1 + ((AVLTreeNode<E>)(node.left)).eigt; else node.eigt = 1 + Mat.max(((AVLTreeNode<E>)(node.rigt)).eigt, ((AVLTreeNode<E>)(node.left)).eigt); /** Return te balance factor of te node */ private int balancefactor(avltreenode<e> node) { if (node.rigt == null) // node as no rigt subtree return -node.eigt; else if (node.left == null) // node as no left subtree return +node.eigt; else return ((AVLTreeNode<E>)node.rigt).eigt - ((AVLTreeNode<E>)node.left).eigt; 17

18 /** Balance te nodes in te pat from te specified * node to te root if necessary */ private void balancepat(e e) { java.util.arraylist<treenode<e>> pat = pat(e); for (int i = pat.size() - 1; i >= 0; i--) { AVLTreeNode<E> A = (AVLTreeNode<E>)(pat.get(i)); updateheigt(a); AVLTreeNode<E> parentofa = (A == root)? null : (AVLTreeNode<E>)(pat.get(i - 1)); switc (balancefactor(a)) { case -2: if (balancefactor((avltreenode<e>)a.left) <= 0) { balancell(a, parentofa); // Perform LL rotation else { balancelr(a, parentofa); // Perform LR rotation break; case +2: if (balancefactor((avltreenode<e>)a.rigt) >= 0) { balancerr(a, parentofa); // Perform RR rotation else { balancerl(a, parentofa); // Perform RL rotation 18

19 /** Balance LL */ private void balancell(treenode<e> A, TreeNode<E> parentofa) { TreeNode<E> B = A.left; // A is left-eavy and B is left-eavy if (A == root) { root = B; else { if (parentofa.left == A) { parentofa.left = B; else { parentofa.rigt = B; A.left = B.rigt; // Make T2 te left subtree of A B.rigt = A; // Make A te left cild of B updateheigt((avltreenode<e>)a); updateheigt((avltreenode<e>)b); 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 19

20 /** Balance RR */ private void balancerr(treenode<e> A, TreeNode<E> parentofa) { TreeNode<E> B = A.rigt; // A is rigt-eavy and B is rigt-eavy if (A == root) { root = B; else { if (parentofa.left == A) { parentofa.left = B; else { parentofa.rigt = B; A.rigt = B.left; // Make T2 te rigt subtree of A B.left = A; updateheigt((avltreenode<e>)a); updateheigt((avltreenode<e>)b); 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 20

21 /** Balance LR */ private void balancelr(treenode<e> A, TreeNode<E> parentofa) { TreeNode<E> B = A.left; // A is left-eavy TreeNode<E> C = B.rigt; // B is rigt-eavy if (A == root) { root = C; else { if (parentofa.left == A) { parentofa.left = C; else { parentofa.rigt = C; A.left = C.rigt; // Make T3 te left subtree of A B.rigt = C.left; // Make T2 te rigt subtree of B C.left = B; A -2 C.rigt = A; 0 or -1 B // Adjust eigts +1 B updateheigt((avltreenode<e>)a); T4 updateheigt((avltreenode<e>)b); C -1, 0, or 1 T1 T2 T1 updateheigt((avltreenode<e>)c); T2 T3 T2 and T3 may ave different eigt, but at least one' must ave eigt of. C 0 A 0 or 1 T3 T4 21

22 /** Balance RL */ private void balancerl(treenode<e> A, TreeNode<E> parentofa) { TreeNode<E> B = A.rigt; // A is rigt-eavy TreeNode<E> C = B.left; // B is left-eavy if (A == root) { root = C; else { if (parentofa.left == A) { parentofa.left = C; else { parentofa.rigt = C; A.rigt = C.left; // Make T2 te rigt subtree of A B.left = C.rigt; // Make T3 te left subtree of B C.left = A; C.rigt = B; // Adjust eigts updateheigt((avltreenode<e>)a); updateheigt((avltreenode<e>)b); updateheigt((avltreenode<e>)c); T1 0, -1, or 1 T2 A +2 C -1 B T3 T4 T2 and T3 may ave different eigt, but at least one' must ave eigt of. 0 or -1 T1 A C 0 B 0 or 1 T2 T3 T4 22

23 @Override /** Delete an element from te binary tree. * Return true if te element is deleted successfully * Return false if te element is not in te tree */ public boolean delete(e element) { if (root == null) return false; // Element is not in te tree // Locate te node to be deleted and also locate its parent node TreeNode<E> parent = null; TreeNode<E> current = root; wile (current!= null) { if (element.compareto(current.element) < 0) { parent = current; current = current.left; else if (element.compareto(current.element) > 0) { parent = current; current = current.rigt; else break; // Element is in te tree pointed by current if (current == null) return false; // Element is not in te tree // Case 1: current as no left cildren if (current.left == null) { // Connect te parent wit te rigt cild of te current node if (parent == null) { 23 root = current.rigt;

24 24 else { if (element.compareto(parent.element) < 0) parent.left = current.rigt; else parent.rigt = current.rigt; // Balance te tree if necessary balancepat(parent.element); else { // Case 2: Te current node as a left cild // Locate te rigtmost node in te left subtree of // te current node and also its parent TreeNode<E> parentofrigtmost = current; TreeNode<E> rigtmost = current.left; wile (rigtmost.rigt!= null) { parentofrigtmost = rigtmost; rigtmost = rigtmost.rigt; // Keep going to te rigt // Replace te element in current by te element in rigtmost current.element = rigtmost.element; // Eliminate rigtmost node if (parentofrigtmost.rigt == rigtmost) parentofrigtmost.rigt = rigtmost.left; else // Special case: parentofrigtmost is current parentofrigtmost.left = rigtmost.left;

25 // Balance te tree if necessary balancepat(parentofrigtmost.element); size--; return true; // Element inserted 25

26 public class TestAVLTree { public static void main(string[] args) { // Create an AVL tree AVLTree<Integer> tree = new AVLTree<>(new Integer[]{25, 20, 5); System.out.print("After inserting 25, 20, 5:"); printtree(tree); tree.insert(34); tree.insert(50); System.out.print("\nAfter inserting 34, 50:"); printtree(tree); tree.insert(30); System.out.print("\nAfter inserting 30"); printtree(tree); tree.insert(10); System.out.print("\nAfter inserting 10"); printtree(tree); 26 tree.delete(34); tree.delete(30); tree.delete(50); System.out.print("\nAfter removing 34, 30, 50:"); printtree(tree);

27 tree.delete(5); System.out.print("\nAfter removing 5:"); printtree(tree); System.out.print("\nTraverse te elements in te tree: "); for (int e: tree) { System.out.print(e + " "); public static void printtree(bst tree) { // Traverse tree System.out.print("\nInorder (sorted): "); tree.inorder(); System.out.print("\nPostorder: "); tree.postorder(); System.out.print("\nPreorder: "); tree.preorder(); System.out.print("\nTe number of nodes is " + tree.getsize()); System.out.println(); 27

28 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 removing 34, 30, 50: Inorder (sorted): Postorder: Preorder: Te number of nodes is 4 After removing 5: Inorder (sorted): Postorder: Preorder: Te number of nodes is 3 Traverse te elements in te tree: After inserting 10 Inorder (sorted): Postorder: Preorder: Te number of nodes is 7 28

29 AVL Tree Time Complexity Analysis Let G() denote te minimum number of te nodes in an AVL tree wit eigt ; G(1) = 1, G(2) = 2 Te minimum number of nodes in an AVL tree wit eigt >2 must ave two minimum subtrees: one wit eigt -1 and te oter wit eigt -2 Tus, G() = G( - 1) + G( - 2) + 1 A Fibonacci number at index i can be described using te recurrence relation: F(i) = F(i - 1) + F(i - 2) Terefore, te function G() is essentially te same as F(i) It can be proven tat < log(n + 2) were n is te number of nodes in te tree Hence, te eigt of an AVL tree is O(log n) 29

30 AVL Tree Time Complexity Analysis 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 Tus, te time complexity for te searc, insert, and delete metods is O(log n) 30