AVL Trees

1
AVL Trees

• ITCS6114
• Algorithms and Data Structures

2
Balanced and unbalanced BST
4
1
2
2
5
3
1
3
4
4
Is this balanced?
5
2
6
6
7
5
7
1
3
3
Perfect Balance

• Want a complete tree after every operation
• tree is full except possibly in the lower right
• This is expensive
• For example, insert 2 in the tree on the left and
  then rebuild as a complete tree

6
5
Insert 2 complete tree
4
9
2
8
8
1
5
6
9
1
4
4
AVL - Good but not Perfect Balance

• AVL trees are height-balanced binary search trees
• Balance factor of a node
• height(left subtree) - height(right subtree)
• An AVL tree has balance factor calculated at
  every node
• For every node, heights of left and right subtree
  can differ by no more than 1
• Store current heights in each node

5
Node Heights
Tree A (AVL)
Tree B (AVL)
2
height2 BF1-01
6
6
1
1
1
0
4
9
4
9
0
0
0
0
0
1
5
8
1
5
height of node h balance factor
hleft-hright empty height -1
6
Node Heights after Insert 7
Tree A (AVL)
Tree B (not AVL)
balance factor 1-(-1) 2
2
3
6
6
1
1
2
1
4
9
4
9
-1
0
0
0
1
0
0
7
1
5
8
1
5
0
7
height of node h balance factor
hleft-hright empty height -1
7
Insert and Rotation in AVL Trees

• Insert operation may cause balance factor to
  become 2 or 2 for some node
• only nodes on the path from insertion point to
  root node have possibly changed in height
• So after the Insert, go back up to the root node
  by node, updating heights
• If a new balance factor (the difference
  hleft-hright) is 2 or 2, adjust tree by rotation
  around the node

8
Single Rotation in an AVL Tree
2
2
6
6
2
1
1
1
4
9
4
8
0
0
1
0
0
0
0
9
7
8
1
5
1
5
0
7
9
Insertions in AVL Trees
Let the node that needs rebalancing be ?. There
are 4 cases Outside Cases (require single
rotation) 1. Insertion into left subtree
of left child of ?. 2. Insertion into right
subtree of right child of ?. Inside Cases
(require double rotation) 3. Insertion
into right subtree of left child of ?. 4.
Insertion into left subtree of right child of ?.
The rebalancing is performed through four
separate rotation algorithms.
10
AVL Insertion Outside Case
j
Consider a valid AVL subtree
k
h
Z
h
h
X
Y
11
AVL Insertion Outside Case
j
Inserting into X destroys the AVL property at
node j
k
h
Z
h1
h
Y
X
12
AVL Insertion Outside Case
j
Do a right rotation
k
h
Z
h1
h
Y
X
13
Single right rotation
j
Do a right rotation
k
h
Z
h1
h
Y
X
14
Outside Case Completed
Right rotation done! (Left rotation is
mirror symmetric)
k
j
h1
h
h
X
Z
Y
AVL property has been restored!
15

AVL Insertion Inside Case
j
Consider a valid AVL subtree
k
h
Z
h
h
X
Y
16
AVL Insertion Inside Case
j
Inserting into Y destroys the AVL property at
node j
Does right rotation restore balance?
k
h
Z
h1
h
X
Y
17
AVL Insertion Inside Case
k
Right rotation does not restore balance now k
is out of balance
j
h
X
h
h1
Z
Y
18
AVL Insertion Inside Case
j
Consider the structure of subtree Y
k
h
Z
h1
h
X
Y
19
AVL Insertion Inside Case
j
Y node i and subtrees V and W
k
h
Z
i
h1
h
X
h or h-1
W
V
20
AVL Insertion Inside Case
j
We will do a left-right double rotation . . .
k
Z
i
X
W
V
21
Double rotation first rotation
j
left rotation complete
i
Z
k
W
V
X
22
Double rotation second rotation
j
Now do a right rotation
i
Z
k
W
V
X
23
Double rotation second rotation
right rotation complete
Balance has been restored
i
j
k
h
h
h or h-1
V
Z
W
X
24
Implementation
balance (1,0,-1)
key
right
left
No need to keep the height just the difference
in height, i.e. the balance factor
this has to be modified on the path of insertion
even if you dont perform rotations Once you have
performed a rotation (single or double) you wont
need to go back up the tree
25
Insertion in AVL Trees

• Insert at the leaf (as for all BST)
• only nodes on the path from insertion point to
  root node have possibly changed in height
• So after the Insert, go back up to the root node
  by node, updating heights
• If a new balance factor (the difference
  hleft-hright) is 2 or 2, adjust tree by rotation
  around the node

26
Insert in AVL trees
Insert(T reference tree pointer, x element)
if T null then T new tree T.data x
height 0 return case T.data x return
//Duplicate do nothing T.data gt x
Insert(T.left, x) if
((height(T.left)- height(T.right)) 2)
if (T.left.data gt x ) then //outside
case T RotatefromLeft
(T) else
//inside case T
DoubleRotatefromLeft (T) T.data lt x
Insert(T.right, x) code similar
to the left case Endcase T.height
max(height(T.left),height(T.right)) 1
return
27
Example of Insertions in an AVL Tree
2
20
Insert 5, 40
1
0
10
30
0
0
35
25
28
Example of Insertions in an AVL Tree
2
3
20
20
1
1
1
2
10
30
10
30
0
0
0
1
0
0
35
5
35
5
25
25
0
40
Now Insert 45
29
Single rotation (outside case)
3
3
20
20
2
1
1
2
10
30
10
30
0
2
0
0
0
1
35
5
40
5
25
25
0
0
35
45
40
1
Imbalance
0
45
Now Insert 34
30
Double rotation (inside case)
3
3
20
20
3
1
1
2
10
30
10
35
0
2
0
0
1
1
40
5
40
5
Imbalance
25
30
0
25
34
45
1
0
45
35
0
Insertion of 34
0
34
31
AVL Tree Deletion

• Similar but more complex than insertion
• Rotations and double rotations needed to
  rebalance
• Imbalance may propagate upward so that many
  rotations may be needed.

32
Pros and Cons of AVL Trees

• Arguments for AVL trees
• Search is O(log N) since AVL trees are always
  balanced.
• Insertion and deletions are also O(logn)
• The height balancing adds no more than a constant
  factor to the speed of insertion.
• Arguments against using AVL trees
• Difficult to program debug more space for
  balance factor.
• Asymptotically faster but rebalancing costs time.
• Most large searches are done in database systems
  on disk and use other structures (e.g. B-trees).