ES 103 Data Structures and Algorithms
AVL Trees
Atul Gupta
AVL Trees [G.M. Adelson-Velsky and E.M. Landis]
What is the major disadvantage of BST?
What is the major advantage of BST?
Most operations on a BST take time proportional to
the height of the tree
Self-balancing binary trees solve this problem by
performing transformations on the tree at key
times, in order to reduce the height.
Although a certain overhead is involved, it is
justified in the long run by ensuring fast
execution of later operations.
Atul Gupta
ES 103 Data Structures and Algorithms
Properties of AVL Trees
the heights of the two child sub-trees of any
node differ by at most one
Lookup (search), insertion, and deletion all
take O(log n) time in both the average and
worst cases
Insertions and deletions may require the tree
to be rebalanced by one or more tree
rotations
Balance Factor
The balance factor of a node x is the height of
its left sub-tree minus the height of its right
sub-tree
balance factor (x) = h(left-sub-tree) h(rightsub-tree)
A node with a balance factor 1, 0, or -1 is
considered balanced
Atul Gupta
ES 103 Data Structures and Algorithms
Computing the Height of a Node in
BST
height(node) {
if (node == null)
return -1
else
return max(height(node.left),
height(node.right)) + 1;
}
Node Heights
Tree A (AVL)
height=2 BF=1-0=1
Tree B (AVL)
2
height of node = h
balance factor = hleft-hright
empty height = -1
Atul Gupta
ES 103 Data Structures and Algorithms
Node Heights after Insert 7
Tree A (AVL)
2
Tree B (not AVL)
balance factor
1-(-1) = 2
-1
0
height of node = h
balance factor = hleft-hright
empty height = -1
AVL Trees
AVL Trees: Examples
Atul Gupta
ES 103 Data Structures and Algorithms
Balancing the BST
root
Z
node* rotate_left(z)
{
node* root = z->right;
z->right = root->left;
root->left = z;
return root;
}
rotate_left(z)
node* rotate_left(z)
{
node* root = z->right;
z->right = root->left;
root->left = z;
return root;
}
Atul Gupta
7
root
2
1
9
5
10
ES 103 Data Structures and Algorithms
rotate_left(z)
node* rotate_left(z)
{
node* root = z->right;
z->right = root->left;
root->left = z;
return root;
}
root
7
10
2
1
rotate_left(z)
node* rotate_left(z)
{
node* root = z->right;
z->right = root->left;
root->left = z;
return root;
}
Atul Gupta
root
7
10
2
1
ES 103 Data Structures and Algorithms
rotate_left(z)
node* rotate_left(z)
{
node* root = z->right;
z->right = root->left;
root->left = z;
return root;
}
root
7
10
2
1
rotate_right(z)
node* rotate_right(z)
{
node root = z->left;
z->left = root->right;
root->right = z;
return root;
}
7
2
1
8
5
root
9
10
Atul Gupta
ES 103 Data Structures and Algorithms
Insert
Insert can cause the balance factor of a node
to become 2 or -2
Only nodes on the path from the insertion
point to the root might have changed
After Insert, traverse up the tree to the root,
updating heights
If a new balance factor is 2 or -2, adjust the
tree by rotation around the node
L
P
if (balance_factor(L) == 2) { //The left column
let P=left_child(L)
if (balance_factor(P) == -1) { //The "Left Right Case"
rotate_left(P //reduce to "Left Left Case"
}
//Left Left Case
rotate_right(L);
} else { // balance_factor(L) == -2, the right column
let P=right_child(L)
if (balance_factor(P) == 1) { //The "Right Left Case"
rotate_right(P) //reduce to "Right Right Case"
}
//Right Right Case
rotate_left(L);
}
Atul Gupta
ES 103 Data Structures and Algorithms
Balancing: One More Time
Atul Gupta
ES 103 Data Structures and Algorithms
AVL Insertion: Left-Left Case
Consider a valid
AVL subtree
AVL Insertion: Left-Left Case
j
k
Inserting into X
destroys the AVL
property at node j
h
h+1
Y
X
Atul Gupta
10
ES 103 Data Structures and Algorithms
AVL Insertion: Left-Left Case
j
k
Do a right rotation
h+1
Y
X
Single right rotation
j
k
Do a right rotation
h+1
Y
X
Atul Gupta
11
ES 103 Data Structures and Algorithms
Left-Left Case Completed
Right rotation done!
(Left rotation is mirror
symmetric)
k
j
h+1
AVL property has been restored!
AVL Insertion: Left-Right Case
Consider a valid
AVL subtree
Atul Gupta
12
ES 103 Data Structures and Algorithms
AVL Insertion: Left-Right Case
Inserting into Y
destroys the
AVL property
at node j
Does right rotation
restore balance?
h+1
AVL Insertion: Left-Right Case
k
j
Right rotation
does not restore
balance now k is
out of balance
h
h+1
Z
Y
Atul Gupta
13
ES 103 Data Structures and Algorithms
AVL Insertion: Left-Right Case
Consider the structure
of subtree Y
h+1
AVL Insertion: Left-Right Case
Y = node i and
subtrees V and W
k
i
h+1
h or h-1
Atul Gupta
14
ES 103 Data Structures and Algorithms
AVL Insertion: Left-Right Case
We will do a left-right
double rotation . . .
k
Z
Double rotation : first rotation
left rotation complete
i
Z
k
W
X
Atul Gupta
15
ES 103 Data Structures and Algorithms
Double rotation : second rotation
Now do a right rotation
i
Z
k
W
X
Double rotation : second rotation
right rotation complete
Balance has been
restored
i
j
k
h
Atul Gupta
h or h-1
16
ES 103 Data Structures and Algorithms
AVL Insertion: Right-Left Case
Inserting into Y
destroys the
AVL property
at node j
A right rotation at k followed
by a left rotation at j will
establish the balance !
j
k
h+1
AVL Tree
Also known as height-balance trees has
average and worse case height as O(log n)
Accordingly, search, insertion and deletion will
be O(log n) [Guaranteed]
Requires more work during insertion, i.e.
check for balancing and possible left and right
rotations. However, this helps in longer run as
the resulting search tree will always be
balanced.
Atul Gupta
17
