AVL Trees

AVL Tree In computer science, an AVL tree is the first-invented self-balancing binary search tree. In an AVL tree the heights of the two child sub-trees of any node differ by at most one. Therefore it is also known as a height- balanced tree.

Height-Balance Property The balance factor of a node is the height of its right subtree minus the height of its left subtree. A node with balance factor 1, 0, or -1 is considered balanced

Advantage Searching in a height-balanced tree is more efficient n = 8 for both trees (where n = number of data elements) maximum number of comparisons = 8 maximum number of comparisons = 3 or 4 O(n) in the worst case O(logn) AVL tree

Balancing an AVL Tree A node with balance factor 1, 0, or -1 is considered balanced A node with any other balance factor is considered unbalanced and requires rebalancing the tree The balance factor is either stored directly at each node or computed from the heights of the sub-trees. Insertion or removal of nodes can cause a balanced tree to become unbalanced After a node is inserted or removed, a restructure operation must be invoked to rebalance the tree

AVLItem Class Objects of this class are stored in the nodes of an AVL tree template class AVLItem : public Item { // AVLItem inherits data members _key, _elem private: int hgt; // It has an additional data member hgt public: AVLItem( const Key& k = Key(), const Element& e = Element(), int h = 0) : Item (k,e), hgt(h) { } int height() const { return hgt; } void setHeight(int h) { hgt = h; } };

AVLTree Class Inherits from the BinarySearchTree class Adds only two public member functions template class AVLTree : public BinarySearchTree >{ //...typedefs and other code inserted here protected: //Utility functions int height( const BTPosition& p ); void setHeight( BTPosition p ); bool isBalanced( const BTPosition& p ); BTPosition tallGrandchild( const BTPosition& p ); void rebalance( BTPosition& p ); public: AVLItem() : BST() { } void insertItem( const Key& k, const Element& e ); void removeElement( const Key& k ); };

Inserting into an AVL Tree Inserting into an AVL tree may be carried out by inserting the given value into the tree as if it were an unbalanced binary search tree, and then retracing one's steps toward the root and rotating about any nodes which have become unbalanced during the insertion A new element is always inserted at an external node Implemented with the insertItem() member function

Inserting an Item void insertItem(const Key& k, const Element& e){ BTPosition p = inserter( k, e ); setHeight(p); rebalance(p); } Begins with the inserter function used by the binary search tree After a new node is inserted, the height of the item at that position is set Finally, the tree is rebalanced

Rebalancing When a new node is added, the heights of some of the existing nodes in the tree may change myAVLTree.insertItem(4);

Rebalancing All of the height changes occur along the path from the new node w to the root w

Rebalancing The rebalance function searches for the first unbalanced node by following the path from w to the root The first unbalanced node it finds is labeled z w z

Rebalancing Three nodes must be identified – z – the first unbalanced node on the path – y – the child of z that has the higher height – x – the grandchild of z that has the higher height z y x

Trinode Restructuring The rebalance function then uses the trinode restructuring function of the binary tree to restore the height balance Trinode restructuring moves nodes x, y, and z by reassigning the pointers z y x

Algorithm restructure( x ) Input: node x that has parent y and grandparent z Output: restructured tree containing x, y, and z Step 1: Rename x, y, and z to a, b, c, from left to right Name their four subtrees T 0, T 1, T 2, T 3, from left to right z y x a b c

Algorithm restructure( x ) Input: node x that has parent y and grandparent z Output: restructured tree containing x, y, and z Step 1: Rename x, y, and z to a, b, c, from left to right Name their four subtrees T 0, T 1, T 2, T 3, from left to right z y x T0T T1T1 T2T2 T3T3 a b c

Algorithm restructure( x ) Step 2: Replace the subtree rooted at z with the subtree rooted at b z y x T0T T2T2 20 T3T3 a b c T1T1

Algorithm restructure( x ) Step 2: Replace the subtree rooted at z with the subtree rooted at b T0T0 414 T2T2 a b T3T3 c temp T1T1 z

Algorithm restructure( x ) Step 3: Let T 0, T 1, be the left and right subtrees of a Let a be the left child of b T0T0 414 T2T2 a b T3T3 c temp T1T1 z

Algorithm restructure( x ) Step 4: Let T 2, T 3, be the left and right subtrees of c Let c be the right child of b T0T0 414 T2T2 a b T3T3 c temp T1T1 z

Algorithm restructure( x ) Step 4: Let T 2, T 3, be the left and right subtrees of c Let c be the right child of b T0T0 414 T2T2 a b T3T3 c T1T1 z

Rebalanced Tree Finally, set the height of z and its children z

rebalance() Member Function void rebalance( BTPosition& z ){ while( !T.isRoot(z) ){ z = T.parent(z); setHeight(z); if( !isBalanced(z) ){ BTPosition x = tallGrandchild(z); z = T.restructure(x); setHeight(T.leftChild(z)); setHeight(T.rightChild(z)); setHeight(z); } Search for an unbalanced node by following the path from the new node to the root Restore the height balance with the trinode restructuring function of the binary tree Set the height of z and its children

4 Cases Require Rebalancing z y x z y x 16 Case 1. Insertion in the left subtree of the left child of z Case 3. Insertion in the right subtree of the left child of z z y x Case 2. Insertion in the right subtree of the right child of z z y x 9 Case 4. Insertion in the left subtree of the right child of z

Restructuring the Four Cases All four cases are restructured by the trinode restructure function Similarities in the cases – Case 1 and Case 2 are mirror images – Case 3 and Case 4 are mirror images

Case 3 Insertion in the right subtree of the left child of z z y x 16 myAVLTree.insertItem(16);

Algorithm restructure( x ) Input: node x that has parent y and grandparent z Output: restructured tree containing x, y, and z Step 1: Rename x, y, and z to a, b, c, from left to right Name their four subtrees T 0, T 1, T 2, T 3, from left to right z y b a c 16 x

Algorithm restructure( x ) Input: node x that has parent y and grandparent z Output: restructured tree containing x, y, and z Step 1: Rename x, y, and z to a, b, c, from left to right Name their four subtrees T 0, T 1, T 2, T 3, from left to right z y T0T T1T1 16 T2T2 T3T3 a c 14 x b

Algorithm restructure( x ) Step 2: Replace the subtree rooted at z with the subtree rooted at b z y 20 T3T3 a c T0T0 8 T1T1 16 T2T2 14 x b

Algorithm restructure( x ) Step 2: Replace the subtree rooted at z with the subtree rooted at b T2T2 b T3T3 c temp z 12 a T0T0 8 temp T1T1

Algorithm restructure( x ) Step 3: Let T 0, T 1, be the left and right subtrees of a Let a be the left child of b T2T2 b T3T3 c temp T1T1 z 12 a T0T0 8 temp

Algorithm restructure( x ) Step 3: Let T 0, T 1, be the left and right subtrees of a Let a be the left child of b T0T0 816 T2T2 a b T3T3 c temp T1T1 z

Algorithm restructure( x ) Step 4: Let T 2, T 3, be the left and right subtrees of c Let c be the right child of b T0T0 816 T2T2 a b T3T3 c temp T1T1 z

Algorithm restructure( x ) Step 4: Let T 2, T 3, be the left and right subtrees of c Let c be the right child of b T0T0 816 T2T2 a b T3T3 c T1T1 z

Rebalanced Tree Finally, set the height of z and its children z

Rotation Another term used to describe the restructuring operation Single rotation used in Cases 1 and

Double Rotation Double rotation used in Cases 3 and

Removing an Element Implemented with the removeElement() member function void removeElement(const Key& k){ BTPosition p = finder( k, T.root() ); if( p.isNull() ) throw NonexistentElementException("Error"); BTPosition r = remover(p); rebalance(r); } Begins with the finder function used by the binary search tree After the node containing that element is located, then it is removed with the remover function of the binary search tree Finally, the tree is rebalanced

Sample Problem Show the result of removing the element with the key of 14 from the AVL tree shown below. The result must be a valid AVL tree. myAVLTree.removeElement(14);