DSA Leactrure # 2! Explaining abstract AVL trees

AVL Trees
Data Structures and Algorithms

2
Binary Search Tree - Worst
Time
• Worst case running time is O(N)
› What happens when you Insert elements in
ascending order?
• Insert: 2, 4, 6, 8, 10, 12 into an empty BST
› Problem: Lack of “balance”:
• compare depths of left and right subtree
› Unbalanced degenerate tree

3
Balanced and unbalanced BST
4
2 5
1 3
1
5
2
4
3
7
6
4
2 6
5 7
1 3
Is this “balanced”?

4
Approaches to balancing trees
• Don't balance
› May end up with some nodes very deep
• Strict balance
› The tree must always be balanced perfectly
• Pretty good balance
› Only allow a little out of balance
• Adjust on access
› Self-adjusting

5
Balancing Binary Search
Trees
• Many algorithms exist for keeping
binary search trees balanced
› Adelson-Velskii and Landis (AVL) trees
(height-balanced trees)
› Splay trees and other self-adjusting trees
› B-trees and other multiway search trees

6
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
Insert 2 &
complete tree
6
4 9
8
1 5
5
2 8
6 9
1 4

7
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

8
Node Heights
1
0
0
2
0
6
4 9
8
1 5
1
height of node = h
balance factor = hleft-hright
empty height = -1
0
0
height=2 BF=1-0=1
0
6
4 9
1 5
1
Tree A (AVL) Tree B (AVL)

9
Node Heights after Insert 7
2
1
0
3
0
6
4 9
8
1 5
1
height of node = h
balance factor = hleft-hright
empty height = -1
1
0
2
0
6
4 9
1 5
1
0
7
0
7
balance factor
1-(-1) = 2
-1
Tree A (AVL) Tree B (not AVL)

10
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

11
Single Rotation in an AVL Tree
2
1
0
2
0
6
4 9
8
1 5
1
0
7
0
1
0
2
0
6
4
9
8
1 5
1
0
7

12
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.
Insertions in AVL Trees

13
j
k
X Y
Z
Consider a valid
AVL subtree
AVL Insertion: Outside Case
h
h
h

14
j
k
X
Y
Z
Inserting into X
destroys the AVL
property at node j
h
h+1 h

15
j
k
X
Y
Z
Do a “right rotation”
h
h+1 h

16
j
k
X
Y
Z
Do a “right rotation”
Single right rotation
h
h+1 h

17
j
k
X Y Z
“Right rotation” done!
(“Left rotation” is mirror
symmetric)
Outside Case Completed
AVL property has been restored!
h
h+1
h

18
j
k
X Y
Z
AVL Insertion: Inside Case
Consider a valid
AVL subtree
h
h
h

19
Inserting into Y
destroys the
AVL property
at node j
j
k
X
Y
Z
Does “right rotation”
restore balance?
h
h+1
h

20
j
k
X
Y
Z
“Right rotation”
does not restore
balance… now k is
out of balance
h
h+1
h

21
Consider the structure
of subtree Y… j
k
X
Y
Z
h
h+1
h

22
j
k
X
V
Z
W
i
Y = node i and
subtrees V and W
h
h+1
h
h or h-1

23
j
k
X
V
Z
W
i
We will do a left-right
“double rotation” . . .

24
j
k
X V
Z
W
i
Double rotation : first rotation
left rotation complete

25
j
k
X V
Z
W
i
Double rotation : second rotation
Now do a right rotation

26
j
k
X V Z
W
i
Double rotation : second rotation
right rotation complete
Balance has been
restored
h
h h or h-1

27
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 don’t perform rotations
Once you have performed a rotation (single or double) you won’t
need to go back up the tree

28
Single Rotation
RotateFromRight(n : reference node pointer) {
p : node pointer;
p := n.right;
n.right := p.left;
p.left := n;
n := p
}
X
Y Z
n
You also need to
modify the heights
or balance factors
of n and p
Insert

29
Double Rotation
• Implement Double Rotation in two lines.
DoubleRotateFromRight(n : reference node pointer) {
????
}
X
n
V W
Z

30
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

31
Example of Insertions in an
AVL Tree
1
0
2
20
10 30
25
0
35
0
Insert 5, 40

32
Example of Insertions in an
AVL Tree
1
0
2
20
10 30
25
1
35
0
5
0
20
10 30
25
1
35
5
40
0
0
0
1
2
3
Now Insert 45

33
Single rotation (outside case)
2
0
3
20
10 30
25
1
35
2
5
0
20
10 30
25
1
40
5
40
0
0
0
1
2
3
45
Imbalance
35 45
0 0
1
Now Insert 34

34
Double rotation (inside case)
3
0
3
20
10 30
25
1
40
2
5
0
20
10 35
30
1
40
5
45
0 1
2
3
Imbalance
45
0
1
Insertion of 34
35
34
0
0
1 25 34
0

35
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.

36
Arguments for AVL trees:
1. Search is O(log N) since AVL trees are always balanced.
2. Insertion and deletions are also O(logn)
3. The height balancing adds no more than a constant factor to the
speed of insertion.
Arguments against using AVL trees:
1. Difficult to program & debug; more space for balance factor.
2. Asymptotically faster but rebalancing costs time.
3. Most large searches are done in database systems on disk and use
other structures (e.g. B-trees).
4. May be OK to have O(N) for a single operation if total run time for
many consecutive operations is fast (e.g. Splay trees).
Pros and Cons of AVL Trees

DSA Leactrure # 2! Explaining abstract AVL trees

More Related Content

Similar to DSA Leactrure # 2! Explaining abstract AVL trees

DSA Leactrure # 2! Explaining abstract AVL trees