AVL Trees
AVL Trees
Binary search trees with a large height/depth are inefficient.
4 6
3 7
2 8
1 9
An AVL (Adelson-Velskii and Landis) tree is a binary search tree with a
balance condition.
The balance condition must be easy to maintain, and it ensures that the
depth of the tree is O(log n).
An AVL tree is identical to a binary search tree, except that for every node
in the tree, the height of the left and right subtrees can differ by at most 1.
The height of an empty tree is defined to be -1.
The height of the left subtree minus the height of the right subtree of a node
is called the balance of the node.
For an AVL tree, the balances of the nodes are always -1, 0 or 1.
AVL - Trees
7
5
2 8
2 8
7 1 4
1 4
3 5
3
An AVL Tree Not an AVL Tree
AVL Trees
5
2 8
7
1 4
6
3
When we do an insertion, we need to update all the balancing
information for the nodes on the path back to the root
but the reason that insertion is potentially difficult is that inserting a
node could violate the AVL tree property.
For instance, inserting 6 into the AVL tree in figure would destroy
the balance condition at the node with key 8.
If this is the case, then the property has to be restored before the
insertion step is considered over.
It turns out that this can always be done with a simple modification to
the tree, known as a rotation.
AVL Trees
After the insertion/rotation operations, the
following properties of the AVL tree must
be restored
(a) the inorder traversal of the transformed
tree is the same as for the original tree (i.e.,
the new tree remains a binary search tree)
(b) the tree after the insertion/rotation is
height balanced.
AVL Trees
After an insertion, only nodes that are on
the path from the insertion point to the root
might have their balance altered
Follow the path up to the root, find the first
node (i.e., deepest) whose new balance
violates the AVL condition.
Call this node α
Rebalance the tree at node α
This guarantees that the entire tree is
balanced.
AVL Trees
Violation may occur when an insertion into
1. left subtree of left child of α (LL case)
2. right subtree of left child of α (LR case)
3. left subtree of right child of α (RL case)
4. right subtree of right child of α (RR
case)
AVL Trees
Violation may occur when an insertion into
1. left subtree of left child of α (LL case)
α
4. right subtree of right child of α (RR case)
α
X
AVL Trees
Violation may occur when an insertion into
2. right subtree of left child of α (LR case)
α
3. left subtree of right child of a α (RL case)
α
X
X
AVL Trees
Rotation
to restore the AVL tree after
insertion
Single rotation
for case 1 and 4
Double rotation
for case 2 and 3
AVL Trees
Single Rotation for case 1
k2 k2
k1 kk11
Z Z
k2
Y Y
X X
Y Z
Single Rotation for case 4
k1 k1
k2 k22
X X
k1
Y Y
Z Z
X Y
AVL Trees: Single Rotation
Example: 3 2 1 4 5 6 7
construct AVL Tree
321
3
3
2
2
1
1
AVL Trees: Single Rotation
Example: 3 2 1 4 5 6 7
construct AVL Tree
321
3
2
2
1 3
1
AVL Trees: Single Rotation
45
2
2
1 4
1 3
3 5
4
5
AVL Trees: Single Rotation
6
1 4 2
5 1 4
3
3 5
6
6
AVL Trees: Single Rotation
7
4
2 5
2 5
1 3 6
1 3 6
7
7
AVL Trees: Double Rotation
Single rotation fails to fix cases 2 and 3
i.e. LR and RL cases
AVL Trees: Double Rotation
Double rotation is used
case 2 (LR case)
Step1: Rotate k1 and k2
Step2: Rotate k2 and k3
AVL Trees: Double Rotation
Double rotation is used
case 2 (LR case)
k3 k3
k1 k1
k2 D k2 D
A A
B C B C
Step1: Rotate k1 and k2
AVL Trees: Double Rotation
Double rotation is used
Step 1: Single Rotation
k1 and k2 rotated
case 2 (LR case)
k3
k3
k1 k2
k2 D
k1 D
A C
B C
A B
LR LL
Step1: Rotate k1 and k2
AVL Trees: Double Rotation
Double rotation is used
Step 2: Single Rotation
k3 and k2 rotated
case 2 (LR case)
k3 k2
k1
k1 k3
k2 D
A
C A B C D
B
LR Balanced
Step2: Rotate k2 and k3
AVL Trees: Double Rotation
case 3 (RL case)
Step1: Rotate k2 and k3
Step2: Rotate k1 and k2
AVL Trees: Double Rotation
Example:
AVL Trees: Double Rotation
16 15
4 4
2 6 6
2
1 3 5 7 k1 k1
1 3 5 7
16 k3 16 k3
15 Double Rotation 15 k2
k2
Step 1: Rotate 15 and 16
AVL Trees: Double Rotation
16 15
4 4
2 6 6
2
1 3 5 7 k1 k1
1 3 5 7
16 k3 15 k2
15 Double Rotation k3 16
k2
Step 2: Rotate 7 and 15
AVL Trees: Double Rotation
Insert 14
Step1: Rotate k2 and k3
Step2: Rotate k1 and k2
AVL Trees: Double Rotation
Insert 13 (This is single rotation: RR Case)
AVL Trees: Double Rotation
Insert 12
AVL Trees: Double Rotation
Insert 11 and 10 (single rotation), then 8
AVL Trees: Double Rotation
Inserting 9
AVL Trees: Declaration
struct avl_node
{
element_type element;
avl_node *left;
avl_node * right;
int height;
};
avl_node * SEARCH_TREE;
AVL Trees: Height Calculation
int height(avl_node * p )
{
if( p == NULL )
return -1;
else
return p->height;
}
Insert operation for binary search
trees
tree_node* insert( int x, tree_node* T ) {
/*1*/ if( T == NULL ) { /* Create and return a one-node tree */
/*2*/ T = (SEARCH_TREE) malloc ( sizeof (struct tree_node) );
/*3*/ if( T == NULL )
/*4*/ printf("Out of space!!!");
else {
/*5*/ T->element = x;
/*6*/ T->left = T->right = NULL;
}
}
/*7*/ else if( x < T->element )
/*8*/ T->left = insert( x, T->left );
/*9*/ else if( x > T->element )
/*10*/ T->right = insert( x, T->right );
/* else x is in the tree already. We'll do nothing */
/*11*/ return T; /* Don't forget this line!! */
}
AVL Trees: Insert Operation
avl_node * insert( int x, avl_node * T) { else if( x > T->element ) {
if( T == NULL ) { /* Create and return a one-node tree */ T->right = insert( x, T->right);
T = (avl_node *) malloc ( sizeof (struct avl_node) );
if( ( height( T->right ) - height( T->left ) ) == 2
if( T == NULL )
if( x > T->right->element )
printf("Out of space!!!");
else { T = SingleRotateWithRight( T );
T->element = x; T->height = 0; else
T->left = T->right = NULL; T = DoubleRotateWithRight( T );
} }
}
/* Else x is in the tree already. We'll do nothing */
else if( x < T->element ) {
T->height = max( height(T->left), height(T->right) ) +
T->left = insert( x, T->left);
1;
if( ( height( T->left ) - height( T->right ) ) == 2
return T;
if( x < T->left->element )
T = SingleRotateWithLeft( T ); }
else
T = DoubleRotateWithLeft( T );
}
AVL Trees: Inserting 16
SEARCH_TREE = insert( 16, SEARCH_TREE)
16
avl_node*insert( int x, avl_node*T){
4 if( T == NULL ){
}
6 else if( x < T->element ) {
2
}
1 3 5 7 else if( x > T->element ) {
T->right = insert( x, T->right);
NULL
AVL Trees: Inserting 16
SEARCH_TREE = insert( 16, SEARCH_TREE)
16
4
2 6
else if( x > T->element ) {
T->right = insert( x, T->right);
1 3 5 7
avl_node*insert( int x, avl_node*T){
if( T == NULL ){
T = (avl_node *) malloc ( sizeof (struct avl_node) );
16
NULL if( T == NULL )
printf("Out of space!!!");
else {
T->element = x; T->height = 0;
T->left = T->right = NULL;
}
Recursion rolls back
AVL Trees: Inserting 16
SEARCH_TREE = insert( 16, SEARCH_TREE)
16
else if( x > T->element ) {
4
T->right = insert( x, T->right);
if( ( height( T->left ) - height( T->right ) ) == 2
{ /*condition is false here */
2 6
}
}
T->height = max( height(T->left), height(T->right) ) + 1;
1 3 5 7 return T;
}
16
AVL Trees: Inserting 15
SEARCH_TREE = insert( 15, SEARCH_TREE)
15
avl_node*insert( int x, avl_node*T){
4 if( T == NULL ){
}
6 else if( x < T->element ) {
2
}
1 3 5 7 else if( x > T->element ) {
T->right = insert( x, T->right);
16
else if( x < T->element ) {
T->left = insert( x, T->left);
NULL
AVL Trees: Inserting 15
SEARCH_TREE = insert( 16, SEARCH_TREE)
15
4 else if( x < T->element ) {
T->reft = insert( x, T->left);
6 avl_node*insert( int x, avl_node*T){
2 if( T == NULL ){
T = (avl_node *) malloc ( sizeof (struct avl_node) );
if( T == NULL )
1 3 5 7 printf("Out of space!!!");
else {
T->element = x; T->height = 0;
T->left = T->right = NULL;
16 }
…
15
NULL …
…
return T; Recursion rolls back
AVL Trees: Inserting 15
SEARCH_TREE = insert( 16, SEARCH_TREE)
15
4 else if( x > T->element ) {
T->right = insert( x, T->right);
}
2 6 avl_node*insert( int x, avl_node*T){
…
…
…
1 3 5 7 return T;
16
15
Recursion rolls back further
AVL Trees: Inserting 15
SEARCH_TREE = insert( 16, SEARCH_TREE)
15
4 else if( x > T->element ) {
T->right = insert( x, T->right);
if( ( height( T->right ) - height( T->left ) ) == 2
if( x > T->right->element )
2 6 T = SingleRotateWithRight( T );
else
T = DoubleRotateWithRight( T );
}
1 3 5 7 /* Else x is in the tree already. We'll do nothing */
T->height = max( height(T->left), height(T->right) ) + 1;
return T;
16}
• Now the subtree writh root 7 is ubalanced
15
perform double rotation with right
AVL Trees: SingleRotateWithLeft
/* This function can be called only if k2 has a left child. */
/* Perform a rotate between a node (k2) and its left child. */
/* Update heights. */
/* Then return new root. */
avl_node * SingleRotateWithLeft( avl_node * k2 ) {
avl_node * k1;
k1 = k2->left;
k2->left = k1->right;
k1->right = k2;
k2->height = max( height(k2->left), height(k2->right) ) + 1;
k1->height = max( height(k1->left), k2->height ) + 1;
return k1; /* New root */
}
Single Rotation for case 1
k2 k1
k2->left
k1 k2
k1->right Z k2->left
X
Y Z
Y
X
AVL Trees: SingleRotateWithRight
/* This function can be called only if k1 has a right child. */
/* Perform a rotate between a node (k1) and its right child. */
/* Update heights. */
/* Then return new root. */
avl_node * SingleRotateWithRight( avl_node * k1 ) {
avl_node * k2;
k2 = k1->right;
k1->right = k2->left ;
k2->left = k1;
k1->height = max( height(k1->left), height(k1->right) ) + 1;
k2->height = max( k1->height, height(k2->right) ) + 1;
return k2; /* New root */
}
Single Rotation for case 4
k1
k1->right k2
k2 k1
X
k2->left k1->right
Y Z
X Y
Z
AVL Trees: DoubleRotateWithLeft
/* This function can be called only if k3 has a left child */
/* and k3's left child has a right child */
/* Do the left-right double rotation. Update heights */
avl_node * DoubleRotateWithLeft( avl_node * k3 )
{
/* rotate between k1 and k2 */
k3->left = SingleRotateWithRight( k3->left );
k3
k3
k1 k2
k2 D
k1 D
A C
B C
A B
AVL Trees: DoubleRotateWithLeft
/* This function can be called only if k3 has a left child */
/* and k3's left child has a right child */
/* Do the left-right double rotation. Update heights */
avl_node * DoubleRotateWithLeft( avl_node * k3 )
{
/* rotate between k1 and k2 */
k3->left = SingleRotateWithRight( k3->left );
/* rotate between k3 and k2 */
return(SingleRotateWithLeft( k3 ) );
}
k3
k3
k1 k2
k2 D
k1 D
A C
B C
A B
AVL Trees: DoubleRotateWithLeft
/* This function can be called only if k3 has a left child */
/* and k3's left child has a right child */
/* Do the left-right double rotation. Update heights */
avl_node * DoubleRotateWithLeft( avl_node * k3 )
{
/* rotate between k1 and k2 */
k3->left = SingleRotateWithRight( k3->left );
/* rotate between k3 and k2 */
return(SingleRotateWithLeft( k3 ) );
}
k3 k2
k1
k1 k3
k2 D
A
C A B C D
B
AVL Trees: DoubleRotateWithLeft
/* This function can be called only if k3 has a left child */
/* and k3's left child has a right child */
/* Do the left-right double rotation. Update heights */
avl_node * DoubleRotateWithLeft( avl_node * k3 )
{
/* rotate between k1 and k2 */
k1 = k3->left;
k2 = SingleRotateWithRight( k1);
k3->left = k2
}
k3
k3
k1 k2
k2 D
k1 D
A C
B C
A B
AVL Trees: DoubleRotateWithLeft
/* This function can be called only if k3 has a left child */
/* and k3's left child has a right child */
/* Do the left-right double rotation. Update heights */
avl_node * DoubleRotateWithLeft( avl_node * k3 )
{
/* rotate between k1 and k2 */
k1 = k3->left;
k2 = SingleRotateWithRight( k1);
k3->left = k2
/* rotate between k3 and k2 */
k2 =SingleRotateWithLeft( k3 )
return(k2);
} k 3
k3
k1 k2
k2 D
k1 D
A C
B C
A B
AVL Trees: DoubleRotateWithLeft
/* This function can be called only if k3 has a left child */
/* and k3's left child has a right child */
/* Do the left-right double rotation. Update heights */
avl_node * DoubleRotateWithLeft( avl_node * k3 )
{
/* rotate between k1 and k2 */
k1 = k3->left;
k2 = SingleRotateWithRight( k1);
k3->left = k2
/* rotate between k3 and k2 */
k2 =SingleRotateWithLeft( k3 )
return(k2);
} k 3 k2
k1 k1 k3
k2 D
A A B C D
B C
AVL Trees: Double Rotation
4 4
2 6 2 6
1 3 5 7 k1 k1
1 3 5 7
16 k3 16 k3
15
k2 Double Rotation 15 k
2
Step 1: Rotate 15 and 16
avl_node * DoubleRotateWithRight( avl_node * k1 )
{
/* rotate between k3 (16) and k2 (15 )*/
k1->right = SingleRotateWithLeft( k1->right );
/* rotate between k1 (7) and k2 (15) */
return(SingleRotateWithRight( k1 ) );
}
AVL Trees: Double Rotation
4 4
2 6 2 6
1 3 5 7 k1 k1
1 3 5 7
16 k3 15 k2
15
k2 Double Rotation k3 16
Step 2: Rotate 7 and 15
avl_node * DoubleRotateWithRight( avl_node * k1 )
{
/* rotate between k3 (16) and k2 (15 )*/
k1->right = SingleRotateWithLeft( k1->right );
/* rotate between k1 (7) and k2 (15) */
return(SingleRotateWithRight( k1 ) );
}
