CE 221

Data Structures and

Algorithms
Chapter 4: Trees (AVL Trees)
Text: Read Weiss, §4.4

Izmir University of Economics 1

 AVL Trees
• An AVL (Adelson-Velskii and Landis) tree is
a binary search tree with a balance
condition. It must be easy to maintain, and
it ensures that the depth of the tree is
O (log N).
• Idea 1: left and
right subtrees are
of the same height
(not shallow).

Izmir University of Economics 2

Balance Condition for AVL Trees
• Idea 2: Every node must have left and right
subtrees of the same height. The height of an
empty tree is -1 (Only perfectly balanced trees
with 2k-1 nodes would satisfy).
AVL Tree = BST with every node satisfying the
property that the heights of left and right
subtrees can differ
only by one.
The tree on the left is
an AVL tree.
The height info is kept
for each node.
Izmir University of Economics 3
 The Height of an AVL Tree - I
• For an AVL Tree with N nodes, the height is at
most 1.44log(N+2)-0.328.
• In practice it is slightly more than log N.
• Example: An AVL tree of height 9 with fewest
nodes (143).

Izmir University of Economics 4

 The Height of an AVL Tree - II
• The minimum number of nodes, S(h), in an AVL tree of
height h is given by S(0)=1, S(1)=2,
S(h) = S(h-1) + S(h-2) +1
• Recall Fibonacci Numbers? (F(0) = F(1) = 1, F(n)=F(n-1) + F(n-2))
• Claim: S(h) = F(h+2) -1 for all h ≥ 0.
• Proof: By induction. Base cases; S(0)=1=F(2)-1=2-1,
S(1)=2=F(3)-1=3-1. Assume by inductive hypothesis that
claim holds for all heights k ≤ h. Then,
• S(h+1) = S(h) + S(h-1) + 1
= F(h+2) -1 +F(h+1) -1 + 1 (by inductive hypothesis)
= F(h+3) – 1
1  1 5   1 5  
h h
• We also know that F ( h)     
5  2   2  
 
Izmir University of Economics 5
 The Height of an AVL Tree - III
 h h h2
1  1 5   1 5   1  1 5 
F ( h)   N  S ( h)  2
5  2   2  
   
5 2  
 
 h  h2
   1  1 5 
F ( h) 
1  1 5  1 N  2 
5  2   5  2 
  1  1 5 
S (h)  F (h  2)  1 log( N  2)   log 5  (h  2) log 

 h2  2  2 
1  1 5  log( N  2)
S ( h)  1  1 2
log 5
h
5  2    1 5   1 5 
  log  2*log 
h2  
 2   2 
1  1 5  1.44 log( N  2)  0.327  h
S ( h)   2
5  2  h  O(log n)
• Thus, all the AVL tree operations can be performed
in O (log N) time. We will assume lazy deletions.
Except possibly insertion (update all the balancing
information and keep it balanced)
Izmir University of Economics 6
 AVL Tree Insertion
• Example: Let’s try to insert 6 into the AVL tree below. This
would destroy the AVL property of the tree. Then this
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 rotation. After an insertion,
only the nodes that are on the path from the insertion point to
the root might have their balance altered. As we follow the
path up to the root and update the
balancing information there may exist
nodes whose new balance violates the
AVL condition. We will prove that our
rebalancing scheme performed once
at the deepest such node works. 6

Izmir University of Economics 7

 AVL Tree Rotations
• Let’s call the node to be balanced α. Since any node has at
most 2 children, and a height imbalance requires that α‘s 2
subtrees’ height differ by 2. There are four cases to be
considered for a violation:
1) An insertion into left subtree of the left child of α. (LL)
2) An insertion into right subtree of the left child of α. (LR)
3) An insertion into left subtree of the right child of α. (RL)
4) An insertion into right subtree of the right child of α. (RR)
• Cases 1 and 4 are mirror image symmetries with respect to α,
as are Cases 2 and 3. Consequently; there are 2 basic cases.
• Case I (LL, RR) (insertion occurs on the outside) is fixed by a
single rotation.
• Case II (RL, LR) (insertion occurs on the inside) is fixed by
double rotation.
Izmir University of Economics 8
 Single Rotation (LL)
• Let k2 be the first node on the path up violating AVL
balance property. Figure below is the only possible
scenario that allows k2 to satisfy the AVL property
before the insertion but violate it afterwards. Subtree
X has grown an extra level (2 levels deeper than Z
now). Y cannot be at the same level as X (k2 then out
of balance before insertion) and Y cannot be at the
same level as Z (then k1 would be the first to violate).

Izmir University of Economics 9

 Single Rotation (RR)
• Note that in single rotation inorder traversal orders
of the nodes are preserved.
• The new height of the subtree is exactly the same
as before. Thus no further updating of the nodes
on the path to the root is needed.

Izmir University of Economics 10

 Single Rotation-Example I
• AVL property destroyed by insertion of
6, then fixed by a single rotation.
• BST node structure needs an additional
field for height.

Izmir University of Economics 11

 Single Rotation-Example II
• Start with an initially empty tree and insert items 1
through 7 sequentially. Dashed line joins the two
nodes that are the subject of the rotation.

Izmir University of Economics 12

 Single Rotation-Example III
Insert 6.
Balance
problem at
the root. So
a single
rotation is
performed.

Finally,
Insert 7
causing
another
rotation.

Izmir University of Economics 13

 Double Rotation (LR, RL) - I
• The algorithm that works for cases 1 and 4 (LL, RR)
does not work for cases 2 and 3 (LR, RL). The
problem is that subtree Y is too deep, and a single
rotation does not make it any less deep.
• The fact that subtree Y has had an item inserted into
it guarantees that it is nonempty. Assume it has a
root and two subtrees.

Izmir University of Economics 14

 Double Rotation (LR) - II
Below are 4 subtrees connected by 3 nodes. Note that
exactly one of tree B or C is 2 levels deeper than D (unless
all empty). To rebalance, k3 cannot be root and a rotation
between k1 and k3 was shown not to work. So the only
alternative is to place k2 as the new root. This forces k1 to
be k2’s left child and k3 to be its right child. It also completely
determines the locations of all 4 subtrees. AVL balance
property is now satisfied. Old height of the tree is restored;
so, all the balancing and and height updating is complete.

Izmir University of Economics 15

 Double Rotation (RL) - III
In both cases (LR and RL), the effect is the same as
rotating between α’s child and grandchild and then
between α and its new child. Every double rotation can be
modelled in terms of 2 single rotations. Inorder traversal
orders are always preserved between k1, k2, and k3.

Double RL = Single LL (α->right)+ Single RR (α)

Double LR = Single RR (α->left)+ Single LL (α )

Izmir University of Economics 16

 Double Rotation Example - I
• Continuing our example, suppose keys 8
through 15 are inserted in reverse order.
Inserting 15 is easy but inserting 14 causes a
height imbalance at node 7. The double
rotation is an RL type and involves 7, 15, and
14.

Izmir University of Economics 17

 Double Rotation Example - II
• insert 13: double rotation is RL that will
involve 6, 14, and 7 and will restore the tree.

Izmir University of Economics 18

 Double Rotation Example - III
• If 12 is now inserted, there is an imbalance at
the root. Since 12 is not between 4 and 7, we
know that the single rotation RR will work.

Izmir University of Economics 19

 Double Rotation Example - IV
• Insert 11: single rotation LL; insert 10: single
rotation LL; insert 9: single rotation LL; insert
8: without a rotation.

Izmir University of Economics 20

 Double Rotation Example - V
• Insert 8½: double rotation LR. Nodes 8, 8½, 9
are involved.

Izmir University of Economics 21

 Implementation Issues - I
• To insert a new node with key X into an AVL
tree T, we recursively insert X into the
appropriate subtree of T (let us call this TLR).
If the height of TLR does not change, then we
are done. Otherwise, if a height imbalance
appears in T, we do the appropriate single or
double rotation depending on X and the keys
in T and TLR, update the heights (making the
connection from the rest of the tree above),
and are done.
Izmir University of Economics 22
 Implementation Issues - II
• Another efficiency issue concerns storage of
the height information. Since all that is really
required is the difference in height, which is
guaranteed to be small, we could get by with
two bits (to represent +1, 0, -1) if we really
try. Doing so will avoid repetitive calculation
of balance factors but results in some loss of
clarity. The resulting code is somewhat more
complicated than if the height were stored at
each node.
Izmir University of Economics 23
 Implementation Issues - III
• First, the declarations. Also, a quick function
to return the height of a node dealing with the
annoying case of a NULL pointer.

Izmir University of Economics 24

 Implementation - LL

/* This function can be called only if k2 has a left */

/* child. Perform a rotate between k2 and its left */
/* child k1. Update heights, then return new root */

Izmir University of Economics 25

 Implementation - RR

/* This function can be called only if k1 has a right */

/* child. Perform a rotate between k1 and its right */
/* child k2. Update heights, then return new root */

private AvlNode<AnyType> rotateWithRightChild(AvlNode<AnyType> k1)

{
AvlNode<AnyType> k2 = k1.right;
k1.right = k2.left;
k2.left = k1;
k1.height = Math.max(height(k1.left), height(k1.right))+1;
k2.height = Math.max(height(k2.right), k1.height)+1;
return k2;
}

Izmir University of Economics 26

 Implementation - LR

/* Double LR = Single RR (α->left)+ Single LL (α ) */

/* This function can be called only if k3 has a left */
/* child and k3's left child k1 has a right child k2 */
/* single rotation between k1 and k2 followed by */
/* single rotation between k3 and k2 */

Izmir University of Economics 27

 Implementation - RL

/* Double RL = Single LL (α->right)+ Single RR (α) */

/* This function can be called only if k1 has a right */
/* child k3 and k1's right child has a left child k2 */

private AvlNode<AnyType> doubleWithRightChild(AvlNode<AnyType> k1)

{
k1.right = rotateWithLeftChild( k1.right );
return rotateWithRightChild( k1 );
}

Izmir University of Economics 28

AVL Tree Insertion

Izmir University of Economics 29

Balancing

Izmir University of Economics 30

AVL Tree Deletion

Izmir University of Economics 31

 Homework Assignments

• 4.18, 4.19, 4.25

• You are requested to study and solve the

exercises. Note that these are for you to
practice only. You are not to deliver the
results to me.

Izmir University of Economics 32