AVL Tree. The height of the BST be as small as possible

Transcription

1 1 AVL Tree re and Algorithm The height of the BST be a mall a poible The firt balanced BST. Alo called height-balanced tree. Introduced by Adel on-vel kii and Landi in BST with the following condition: 1- The height of the left and right ub-tree of the root differ by at mot The left and right ub-tree of the root are alo AVL tree. In other word, for all node v in the tree, the difference in height of the left and right ub-tree of v i no greater than 1.

2 2 re and Algorithm An AVL Tree i a binary earch tree uch that forevery internal node v of T, T the height ht of the children of v can differ by at mot 1. Thee condition enure that t the depth of the tree i O (Log N) where N i the number of element in the tree. Suppoe that, v i a node in an AVL tree then: If left v > right vthenvilefthigh v high If left v = right v then v i equal high If left v < right v then v i right high

3 3 re and Algorithm In addition to the data and reference, each node tore one more thing which i the balance factor. The balance factor for node x i a value uch that: If v i left high then the balance factor of v i -1 If v i equal high then the balance factor of v i 0 If v i right high then the balance factor of v i 1. Since AVL tree i a BST, therefore, the earch operation in an AVL tree ue the ordinary BST earch algorithm. Becaue of the logarithmic depth of an AVL tree, the earch operation in an AVL tree have logarithmic wort-cae bound. However, inertion and deletion algorithm are different than BST algorithm. After inertion or deletion, the balance criteria mut be retored.

4 4 Data Structure and Algorithm

5 5 Data Structure and Algorithm

6 6 Data Structure and Algorithm

7 7 re and Algorithm For inerting a new item into an AVL tree, firt we earch the tree to find the place for the new item. If the item i already in the tree, the earch end with at a non-empty ubtree. Becaue duplicate i not allowed in AVL tree therefore, we can output an appropriate error meage. If the item i not in the tree then the earch end at an empty ub-tree and we inert the new item in that ub-tree. After inerting the new item, the reulting tree may not be an AVL tree. Thu we mut retore the tree balance criteria. Only the node that are on the path from the inertion point to the root might have their balance changed. Therefore, we follow the ame path, back to the root, which wa followed when the new item wa inerted in the AVL tree. The node on thi path are viited and either their balance factor i changed, or we might have to recontruct part of the tree. If we find a node whoe new balance factor violate the AVL tree condition we will rebalance the tree by rotation.

8 8 re and Algorithm Suppoe that the node to be rebalanced i X. Since any node ha at mot two children and the height imbalance in an AVL tree require that the height of the two ub-tree of X i differ by more than 1, therefore, a violation may occur in any of the following cae: An inertion into the left ub-tree of the left child of X An inertion into the right ub-tree of the left child of X An inertion into the left ub-tree of the right child of X An inertion into the right ub-tree of the right child of X Cae 1 and cae 4 are ymmetric and in thee two cae the inertion occur on the outide (that i left-left or right-right), can be fixed by ingle rotation. A ingle rotation change the role of the parent and child while maintaining the earch order for the tree.

9 9 re and Algorithm A ingle rotation can be left or right. If the rotation occur at node x and it i a left rotation, then ome node from the right ubtree of x move to it left ub-tree. The root of the right ub-tree of x become the new root of the recontructed ub-tree. Similarly, if it i a right rotation at node x, ome node from the left ub-tree of x move to it right ub-tree and the root of the left ub-tree of x become the new root of the recontructed t ub-tree.

10 10 re and Algorithm Cae 2 and cae 3, in which the inertion occur on the inide (that i, left-right or right-left), are complex and can be fixed by double rotation. The double rotation i required when the balance factor of the node where the tree i to be recontructed and the balance factor of the higher ub-tree are oppoite. In thi cae firt we rotate the tree at the lower node and then at the upper node. If the lower ub-tree i right high, we make a left rotation and if it i left high we make a right rotation. ti Secondly we rotate t the tree at the upper node. It the tree rooted at the upper node i left high, we make a right rotation and if it i right high, we make a left rotation.

11 11 re and Algorithm To remove a node from an AVL tree, firt we earch the tree to find the node to be removed. If we find the node, we can remove it in the ame way a we remove a node from am ordinary BST. The difference i that, after removing the node, the BST may not be an AVL tree. There may be an unbalanced node in the tree on the path from the parent of the deleted node to the root of the tree. In fact, there can be one uch unbalanced node at mot. Therefore, after deletion we have to retore the balance criteria for the tree. To do thi we follow the path from the parent of the deleted node back to the root node. We viit each node on thi path, and ometime we need to node i recontructed. Suppoe that v i a node on the path back to the root node. We check the current balance change only the balance factor, while other time the tree at a particular factor of v.

12 12 re and Algorithm If the current balance factor of v i equal high, then the balance factor of v i changed according to whether the left ub-tree of v wa hortened or the right ub-tree of v wa hortened. Suppoe that the balance factor of v i not equal high and the taller ub-tree of v i hortened. The balance factor of v i changed to equal high. Suppoe that the balance factor of v i not equal high and the horter ub-tree of v i hortened. Alo uppoe that q point to the root of the taller ub-tree of v. If the balance factor of q i equal high, a ingle rotation i required at v. If the balance factor of q i the ame a v, a ingle rotation i required at v. Suppoe that the balance factor of v and q are oppoite. A double rotation i required at v (a ingle rotation at q and then a ingle rotation at v). [D. S. Malik].

13 13 Algorithm ta Structure and A Dat AVL tree before inerting i 90.

14 14 re and Algorithm For inerting 90 we earch the tree tarting at the root node to find the place for 90.

15 15 Algorithm ta Structure and A Dat AVL tree after inerting 90 and adjuting the balance factor

16 16 Now conider the following AVL tree: Algorithm ta Structure and A Dat Let u inert 75 into the tree:

17 17 re and Algorithm A before we earch the tree tarting at the root node. After inerting 75, the reulting BST i:

18 18 Data Structure and Algorithm

19 19 Conider the following tree: Data Structure and Algorithm

20 20 re and Algorithm Now inert 95 into thi AVL tree. After inerting 95 the tree will be:

21 21 Data Structure and Algorithm

22 22 re and Algorithm Let u conider one more cae. Conider the following AVL tree:

23 23 Now let u inert 88 into thi tree. The tree will be: Algorithm ta Structure and A Dat Node other than 88 how their balance factor before inertion

24 24 re and Algorithm ta Structu Dat A before, we now backtrack to the root node. We adjut the balance factor of node 85 and 90. When we viit node 80, we dicover that at thi node we need to recontruct the ub-tree. The tree will be:

25 25 re and Algorithm To make the algorithm efficient, we tore the balance factor of each node in the node itelf. cla avlitem { int idno; String firtname; int bfactor; avlitem leftchild; avlitem rightchild;

26 re and Algorithm 26 Inertion into AVL Tree cla avlitemlit { public avlitem root; public boolean unbalance = fale; public void inert(int id, String name) { avlitem newtudent = new avlitem (); newtudent.idno idno= id; newtudent.firtname = name; newtudent.bfactor = 0; newtudent.leftchild = null; newtudent.rightchild = null; root = inertavl(root, newtudent);

27 27 public avlitem inertavl(avlitem root, avlitem newtudent) { re and Algorithm if(root == null) { root = newtudent; unbalance =true; ele if (root.idno == newtudent.idno) Sytem.err.println("No duplicate are allowed"); ele if (root.idno > newtudent.idno) { root.leftchild = inertavl(root.leftchild, newtudent);

28 28 re and Algorithm if (unbalance ) witch(root.bfactor) { cae -1 : root = balancefromleft(root); unbalance =fale; break; cae 0 : root.bfactor = -1; unbalance = true; break; cae 1 : root.bfactor = 0; unbalance = fale;

29 29 re and Algorithm ele { root.rightchild rightchild = inertavl(root.rightchild, rightchild newtudent); if (unbalance ) witch(root.bfactor) { cae -1 : root.bfactor = 0; unbalance = fale; break; cae 0 : root.bfactor = 1; unbalance = true; break; cae 1 : root = balancefromright(root); unbalance = fale; return root;

30 30 re and Algorithm public avlitem balancefromright(avlitem root) { avlitem p; avlitem w; p = root.rightchild; witch (p.bfactor) { cae -1 : w = p.leftchild; witch(w.bfactor) { cae -1 : root.bfactor = 0; p.bfactor = 1; break; cae 0 : root.bfactor = 0; p.bfactor = 0; break; cae 1 : root.bfactor = -1; p.bfactor = 0;

31 31 re and Algorithm w.bfactor = 0; p = rotatetoright(p); root.rightchild = p; root = rotatetoleft(root); break; cae 0 : Sytem.err.println("can't balance from the right"); break; cae 1 : root.bfactor = 0; p.bfactor = 0; root = rotatetoleft(root); return root;

32 32 re and Algorithm public avlitem balancefromleft(avlitem root) { avlitem p; avlitem w; p = root.leftchild; witch(p.bfactor) { cae -1 : root.bfactor = 0; p.bfactor = 0; root = rotatetoright(root); break; cae 0 : Sytem.err.println("can't balance from the left"); break; cae 1 : w = p.rightchild;

33 33 re and Algorithm witch (w.bfactor) { cae -1 :root.bfactor tbf t = 1; p.bfactor = 0; break; cae 0 : root.bfactor =0; p.bfactor = 0; break; cae 1 : root.bfactor = 0; p.bfactor = -1; w.bfactor = 0; p = rotatetoleft(p); root.leftchild = p; root = rotatetoright(root); return root;

34 34 re and Algorithm public avlitem rotatetoright (avlitem root) { avlitem p; if (root == null) Sytem.err.println("Error in the tree"); ele if (root.leftchild == null) Sytem.err.println("No left ubtree"); ele { p = root.leftchild; root.leftchild = p.rightchild; root.leftchild = p.rightchild; p.rightchild = root; root = p; return root;

35 35 re and Algorithm public avlitem rotatetoleft(avlitem root) { avlitem p; if (root == null) Sytem.err.println("Error in the tree"); ele if (root.rightchild == null) Sytem.err.println("No right ubtree"); ele { p = root.rightchild; root.rightchild = p.leftchild; p.leftchild = root; root = p; return root;

36 36 re and Algorithm cla avlapp { public tatic void main (String [] arg){ avlitemlit tree1 = new avlitemlit(); tree1.inert(50, "Farid"); tree1.inert(40, "Faial"); tree1.inert(70, "Zabi"); tree1.inert(80, "Karim"); tree1.inert(75, "Wali"); tree1.travere();

37 37 re and Algorithm ta Structu Dat A before, after recontructing the ub-tree, the entire tree i balanced. So for the remaining i node on the path back to the root node, we do nothing.