Lesson 21: AVL Trees. Rotation

Transcription

1 The time required to perform operations on a binary search tree is proportional to the length of the path from root to leaf. This isn t bad in a well-balanced tree. But nothing prevents a tree from becoming unbalanced. In the extreme, such as the tree shown on the right, the tree reduces to nothing more than a linked list, and the path from root to leaf is O(n). To preserve fast performance we need to ensure that the tree remains well balanced. One way to do this is to notice that the search tree property has some flexibility. Three nodes that are unbalanced can be restored by a rotation, making the right child into the new root, with the previous root as the new left child. Any existing left child of the old right child becomes the new right child of the new left child. The resulting tree is still a binary search tree, and has better balance. 5 9 Rotation This is known as a left rotation. There is also a corresponding right rotation. There is one case where a simple rotation is not sufficient. Consider an unbalanced tree with a right child that itself has a left child. If we perform a rotation, the result is still unbalanced. An Active Learning Approach to Data Structures using C 1

2 The solution is to first perform a rotation on the child, and then rotate the parent. This is termed a double rotation. The data structure termed the AVL tree was designed using these ideas. The name honors the inventors of the data structure, the Russian mathematicians Georgii M. Adel son- Vel skiĭ and Evgeniĭ Mikhaĭlovich Landis. In order to know when to perform a rotation, it is necessary to know the height of a node. We could calculate this amount, but that would slow the algorithm. Instead, we modify the node so that each node keeps a record of its own height (in a variable called hght). struct AVLNode { TYPE val; struct Node *left; struct Node *rght; int hght; A function _height will be useful to determine the height of a child node. Since leaf nodes have height zero, a value of 1 is returned for a null value. Using this, a method _setheight can be defined that will set the height value of a node, assuming that the height of the child nodes is known: int _height(struct AVLNode *cur) { if (cur == 0) return -1; return cur->hght; void _setheight(struct AVLNode *cur) { int lh = _height(cur->left); int rh = _height(cur->rght); if (lh < rh) cur->hght = rh + 1; else cur->hght = lh + 1; Armed with the height information, the AVL tree algorithms are now easy to describe. The addition and removal algorithms for the balanced binary search tree are modified so that their very last step is to invoke the function _balance: struct AVLNode *_addnode(struct AVLNode *cur, TYPE val) { if (cur == 0) { cur = (struct AVLNode *)malloc(sizeof(struct AVLNode)); assert(cur!= 0); An Active Learning Approach to Data Structures using C 2

3 cur->val = val; cur->left = cur->rght = 0; cur->hght = 0; return cur; if (LT(val, cur->val)) cur->left = _addnode(cur->left, val); else cur->rght = _addnode(cur->rght, val); return _balance(cur); /* Call balance on result. */ The function _balance performs the rotations necessary to restore the balance in the tree. Let the balance factor be the difference in height between the right and left child trees. This is easily computed using a function. If the balance factor is more than 2, that is, if one subtree is more than two levels different in height from the other, then a rebalancing is performed. A check must be performed for double rotations, but again this is easy to determine using the balance factor function. Once the tree has been rebalanced the height is set by calling _setheight: int _bf(struct Node *cur) { return _height(cur->rght) - _height(cur->left); Node *_balance(struct Node *cur) { int cbf = _bf(cur); if (cbf < -1) { if (_bf(cur->left) > 0) /* Check for double rotation. */ cur->left = _rotateleft(cur->left); return _rotateright(cur); /* Single rotation. */ else if (cbf > 1) { if (_bf(cur->rght) < 0) cur->rght = _rotateright(cur->rght); return _rotateleft(cur); _setheight(cur); return cur; Since the balance function looks only at a node and its two children, the time necessary to perform rebalancing is proportional to the length of the path from root to leaf. Insert the values 1 to 7 into an empty AVL tree and show the resulting tree after each step. Remember that rebalancing is performed bottom up after a new value has been inserted and only if the difference in heights of the child trees are more than two. An Active Learning Approach to Data Structures using C

4 Complete the implementation of the AVLTree data structure by writing the methods to perform a left and right rotation. Both these methods should call _setheight on both the new interior node that has been changed and the new top node. Other methods that are similar to those of the Binary Search Tree have been omitted: struct AVLTree { struct AVLNode *root; int cnt; void initavltree(struct AVLTree *tree) { tree->root = 0; tree->cnt = 0; /* Add and remove same as BST. */ void add(struct AVLTree *tree, TYPE val) {... void remove(struct AVLTree *tree, TYPE val) {... struct AVLNode *_addnode(struct AVLNode *cur, TYPE val) {... /* Same as BST. */ return _balance(cur); struct AVLNode *_remove(struct AVLNode *cur, TYPE val) {... /* Same as BST. */ return _balance(cur); struct AVLNode *_removeleftmost(struct AVLNode *cur) {... /* Same as BST. */ return _balance(cur); struct AVLNode *_rotateleft(struct AVLNode *cur) { An Active Learning Approach to Data Structures using C

5 struct AVLNode *_rotateright(struct AVLNode *cur) { /* Same as _rotateleft except you swap left for rght. */ An Active Learning Approach to Data Structures using C 5

6 On Your Own So how close to being well balanced is an AVL tree? Recall that the definition asserts the difference in height between any two children is no more than one. This property is termed a height-balanced tree. Height balance assures that locally, at each node, the balance is roughly maintained, although globally over the entire tree differences in path lengths can be somewhat larger. The following shows an example height-balanced binary tree. A complete binary tree is also height balanced. Thus, the largest number of nodes in a balanced binary tree of height h is 2 h+1 1. An interesting question is to discover the smallest number of nodes in a height-balanced binary tree. For height zero there is only one tree. For height 1 there are three trees, the smallest of which has two nodes. In general, for a tree of height h the smallest number of nodes is found by connecting the smallest tree of height h 1 and h 2. If we let M h represent the function yielding the minimum number of nodes for a height balanced tree of height h, we obtain the following equations: M 0 = 1 M 1 = 2 M h+1 = M h-1 + M h + 1 These equations are very similar to the famous Fibonacci numbers defined by the formula f 0 = 0, f 1 = 1, f n+1 = f n-1 + f n. An induction argument can be used to show that M h = f h+ 1. It is easy to show using induction that we can show that the Fibonacci An Active Learning Approach to Data Structures using C

7 numbers have an upper bound of 2 n. In fact, it is possible to establish an even tighter bounding value. Although the details need not concern us here, the Fibonacci numbers have a closed form solution; that is, a solution defined without using recursion. The value F h is approximately where F h h φ φ = is the golden mean. Using this information, we can show that the function M h also has an approximate closed form solution: M h h φ 5 1 By taking the logarithm of both sides and discarding all but the most significant terms we obtain the result that h is approximately 1. log M h. This tells us that the longest path in a height-balanced binary tree with n nodes is at worst only % larger than the log n minimum length. Hence algorithms on height-balanced binary trees that run in time proportional to the length of the path are still O(log n). More importantly, preserving the height balanced property is considerably easier than maintaining a completely balanced tree. Because AVL trees are fast on all three bag operations they are a good general purpose data structure useful in many different types of applications. An Active Learning Approach to Data Structures using C 7