1. An AVL tree is a self-balancing binary search tree where the height of the left and right subtrees of every node differ by at most 1. 2. AVL trees perform rotations during insertions and deletions to maintain the balance property. There are four cases of rotations that can occur - left subtree heavy, right subtree heavy, left subtree becomes right heavy, right subtree becomes left heavy. 3. The balance factor of a node is defined as the height of its left subtree minus the height of its right subtree, and must be between -1 and 1 for the tree to remain balanced.

1. .AVL TREES
Adelson-Velskii and Landis (AVL)
trees (height-balanced trees)

2. AVL Tree
AVL Tree is a height balanced binary search tree in which
the height of left subtree and height of right subtree can
differ at most by 1. Figure 1 shows an example of AVL
tree and Figure 2 shows a non-AVL tree.
50
40
4530
80
90
80
50
6040
90
4530
60

3. Operations on AVL Tree
• Insertion
• Deletion
• Search
The operations performed on an AVL tree is similar to that
of a binary search tree. The only additional requirement
is the tree balancing i.e. after insertion and deletion, we
must ensure that the tree is balanced.
For tree balancing, we perform rotation operation which
rotates the tree without affecting the ordering.
There are two types of rotation:
left rotation and

4. Left Rotation
50
40
4530
80
9060
80
50
6040
90
90
4530

5. Right Rotation
50
40
4530
80
9060
40
50
8045
30
60 90

6. Left Rotation and Right Rotation
Left Rotation
store the right of pivot in temp
attach left of temp to right of pivot
attach pivot to left of temp
update necessary parent pointers
update root, if required
Right Rotation
store the left of pivot in temp
attach right of temp to left of pivot
attach pivot to right of temp
update necessary parent pointers
update root, if required

7. Right Rotation - Pseudo code
void right_rotation(struct node *p)
{
if (p->left != NULL)
{
struct node *x;
x = p->left; // store the left child pivot in x
p->left = x->right; // attach x->right child to pivots's left
if (x->right!=NULL) x->right->parent = p; // update parent ptr of x
x->right = p; // attach pivot to right of x
if (p->parent != NULL)
if(p == p->parent->right) p->parent->right=x;
else
p->parent->left = x;
x->parent = p->parent;
p->parent = x;
if (p == root) //update root if required
root = x;
}
}

8. Left Rotation
void left_rotation(struct node *p)
{
if (p->right != NULL)
{
struct node *x;
x = p->right; //store the right of pivot in x
p->right = x->left; //attach x left to pivot's right
if (x->left!=NULL) x->left->parent = p; // update x's left parent ptr
x->left = p; // attach pivot to left of x
if (p->parent != NULL)
if (p==p->parent->left) p->parent->left=x;
else
p->parent->right=x;
x->parent = p->parent;
p->parent = x;
if(p == root)
root=x;
}
}

9. void right_rotation(struct node *p)
{
if (p->left != NULL)
{
struct node *x;
x = p->left;
p->left = x->right;
if (x->right!=NULL)
x->right->parent = p;
x->right = p;
if (p->parent != NULL)
if(p == p->parent->right)
p->parent->right=x;
else
p->parent->left = x;
x->parent = p->parent;
p->parent = x;
if (p == root)
root = x;
}
}
void left_rotation(struct node *p)
{
if (p->right != NULL)
{
struct node *x;
x = p->right;
p->right = x->left;
if (x->left!=NULL)
x->left->parent = p;
x->left = p;
if (p->parent != NULL)
if (p==p->parent->left)
p->parent->left=x;
else
p->parent->right=x;
x->parent = p->parent;
p->parent = x;
if (p == root)
root=x;
}
}
root IS THE GLOBAL VARIABLE

10. Balance Factor and Rotation Effect
50
(+1)
40
(0)
75
(0)
45
(0)
30
(0)
50
(+2)
40
(+1)
75
(0)
45
(0)
30
(+1)
25
(0)
40
(0)
30
(+1)
50
(0)
50
(0)
25
(0)
75
(0)

11. Recall
Definition of AVL Tree
Balance Factor
Tree Rotation
Single Rotation
left rotation
Right rotation
Double Rotation
left-right rotation
right-left rotation
Implementation of Rotation Operation

12. Insert Operation
Case 1: left subtree becomes left heavy
Case 2: right subtree becomes right heavy
Case 3: left subtree becomes right heavy
Case 4: right subtree becomes left heavy

13. Case 1: left subtree becomes left heavy

50
(+1)
40
(0)
75
(0)
45
(0)
30
(0)
50
(+2)
40
(+1)
75
(0)
45
(0)
30
(+1)
25
(0)
40
(0)
30
(+1)
50
(0)
50
(0)
25
(0)
75
(0)

14. Case 2: right subtree becomes right heavy
50
(-1)
40
(0)
75
(0)
80
(0)
70
(0)
50
(-2)
40
(0)
75
(-1)
80
(-1)
70
(0)
85
(0)
50
(0)
40
(0)
75
(0)
80
(-1)
70
(0)
85
(0)

15. Case 3: right subtree becomes left heavy
50
(-1)
40
(0)
75
(0)
80
(0)
70
(0)
50
(-2)
40
(0)
75
(+1)
80
(+1)
70
(+1)
69
(0)
50
(-2)
40
(0)
70
(-1)
75
(-1)
69
(0)
80
(0)
50
(0)
40
(0)
70
(0)
75
(-1)
69
(0)
80
(0)

16. Case 4: left subtree becomes right heavy
50
(+1)
40
(0)
75
(0)
45
(0)
30
(0)
50
(+2)
40
(-1)
75
(0)
45
(-1)
30
(+1)
49
(0)
50
(+2)
40
(-1)
75
(0)
45
(-1)
30
(+1)
49
(0)

17. Summary of insert operation
 Perform insertion like a normal BST
 After insertion update the balance factor in the
insertion path
 if critical node is encountered (node having bf>1
or bf<-1), perform appropriate rotation and then
update the balance factors.

18. AVL Tree Implementation
The following slides provides some implementation
details for implementing AVL trees
In AVL Tree insertion, we need to keep track of the
path and direction of newly inserted node.
A stack or list may be used for achieving this. The
code snippets shown in the subsequent slides
uses list.

19. Insertion is same as BST, However you need to keep track of
the path and direction
//scan through the binary tree
node *prev=NULL, *curr=root; level=0;
while (curr != NULL)
{
prev = curr;
level++;
if (key < curr->key)
{
NPTR[level]=curr; ROUTE[level]='L';
curr = curr->left;
}
else if (key > curr->key)
{
NPTR[level]=curr; ROUTE[level]='R';
curr = curr->right;
}
else
{
printf("key Already Exists"); return;
}
}

20. //create a node and assign the key
node *newnode = (struct node *)malloc(sizeof(struct node));
newnode->key = key;
newnode->bfactor=0;
newnode->left = newnode->right = NULL;
newnode->parent=prev;
//insert the node
if (prev==NULL)
root = newnode;
else
{
if (key < prev->key)
prev->left = newnode;
else
prev->right = newnode;
}

21. CASE 1 AND CASE 2
for(int i=level-1;i>=1;i--)
{
if (ROUTE[i]=='L') NPTR[i]->bfactor++;
else NPTR[i]->bfactor--;
if (NPTR[i]->bfactor>1 or NPTR[i]->bfactor< -1 ) //critical node
{
if( ROUTE[i] == 'L' and ROUTE[i+1] == 'L' ) //case 1
{
X = NPTR[i]; Y = NPTR[i+1];
rightrotation( X );
X->bfactor=Y->bfactor = 0;
}
else if( ROUTE[i] == 'R' and ROUTE[i+1] =='R' ) //case 2,
{
X = NPTR[i]; Y = NPTR[i+1];
leftrotation( X );
X->bfactor = Y->bfactor = 0;
}

22. CASE 3 AND CASE 4
else if ( ROUTE[i]=='L' and ROUTE[i+1] == 'R' ) //case 3
{
X = NPTR[i]; Y = NPTR[i+1]; Z = NPTR[i+2];
leftrotation(Y);
rightrotation(X);
if(Z->bfactor == +1) { X->bfactor=-1; Y->bfactor=0; Z->bfactor=0; }
else if(Z->bfactor == -1) { X->bfactor=0; Y->bfactor=1; Z->bfactor=0; }
else { X->bfactor=0; Y->bfactor=0; Z->bfactor=0; }
}
else if ( ROUTE[i]=='R' and ROUTE[i+1] == 'L' ) //case 4,
{
X = NPTR[i]; Y = NPTR[i+1]; Z = NPTR[i+2];
rightrotation(Y);
leftrotation(X);
if(Z->bfactor == -1) { X->bfactor=1; Y->bfactor=0; Z->bfactor=0; }
else if(Z->bfactor == 1) { Y->bfactor=-1; Z->bfactor=0; X->bfactor=0; }
else { X->bfactor=0; Y->bfactor=0; Z->bfactor=0; }
}
break;

24. ASSESSMENT
1. Insert the following elements into an empty
binary search tree with balance indicators:
5,4,3,2,1. Then the balance factor of root
node is
A. +4
B. -4
C. +3
D. -3

25. Contd..
2. Insert the following elements into an empty
binary search tree with balance indicators:
5,4,3,2,1. Then the root node after performing
right rotation with respect to root is
A. 5
B. 4
C. 1
D. 2

26. Contd..
3. The maximum balance factor a node can
arrive at during insertion operation into an avl
tree is
A. +2 or -2
B. -1 or +1
C. +1 only
D. -1 only

27. Contd..
4. A left rotation cannot be performed if
A. the right child of pivot is null
B. the left child of pivot is null
C. the pivot element is root
D. the pivot element is the left child of the root

28. Contd..
5. The inorder traversal of the AVL tree is 30,
40, 45, 50 and 75. Then the balance factor of
the root node is
A. +2
B. -2
C. +1 or -1
D. -1 or -2