Transcript
Advance Data Structures
Lecture 3 AVL Trees
2
Binary Search Tree - Best Time
• All BST operations are O(h), where h is tree height
• minimum h is for a binary tree with N nodes› What is the best case tree? › What is the worst case tree?
• So, best case running time of BST operations is O(log N)
Nlogh 2
3
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 height of left and right subtree
› Unbalanced degenerate tree
4
Balanced and unbalanced BST
4
2 5
1 3
1
5
2
4
3
7
6
4
2 6
5 71 3
Is this “balanced”?
5
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
6
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
7
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
81 5
5
2 8
6 91 4
8
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
9
Height of an AVL Tree
• N(h) = minimum number of nodes in an AVL tree of height h.
• Basis› N(0) = 1, N(1) = 2
• Induction› N(h) = N(h-1) + N(h-2) + 1
• Solution (recall Fibonacci analysis)
› N(h) > h ( 1.62) h-1h-2
h
10
Height of an AVL Tree
• N(h) > h ( 1.62)• Suppose we have n nodes in an AVL
tree of height h.› n > N(h) (because N(h) was the minimum)
› n > h hence log n > h (relatively well balanced tree!!)
› h < 1.44 log2n (i.e., Find takes O(logn))
11
Node Heights
1
00
2
0
6
4 9
81 5
1
height of node = hbalance 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)
12
Node Heights after Insert 7
2
10
3
0
6
4 9
81 5
1
height of node = hbalance 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)
13
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
14
Single Rotation in an AVL Tree
2
10
2
0
6
4 9
81 5
1
0
7
0
1
0
2
0
6
4
9
8
1 5
1
0
7
15
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
16
j
k
X Y
Z
Consider a validAVL subtree
AVL Insertion: Outside Case
h
hh
17
j
k
XY
Z
Inserting into Xdestroys the AVL property at node j
AVL Insertion: Outside Case
h
h+1 h
18
j
k
XY
Z
Do a “right rotation”
AVL Insertion: Outside Case
h
h+1 h
19
j
k
XY
Z
Do a “right rotation”
Single right rotation
h
h+1 h
20
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
21
j
k
X Y
Z
AVL Insertion: Inside Case
Consider a validAVL subtree
h
hh
22
Inserting into Y destroys theAVL propertyat node j
j
k
XY
Z
AVL Insertion: Inside Case
Does “right rotation”restore balance?
h
h+1h
23
jk
X
YZ
“Right rotation”does not restorebalance… now k isout of balance
AVL Insertion: Inside Case
hh+1
h
24
Consider the structureof subtree Y… j
k
XY
Z
AVL Insertion: Inside Case
h
h+1h
25
j
k
X
V
Z
W
i
Y = node i andsubtrees V and W
AVL Insertion: Inside Case
h
h+1h
h or h-1
26
j
k
X
V
Z
W
i
AVL Insertion: Inside Case
We will do a left-right “double rotation” . . .
27
j
k
X V
ZW
i
Double rotation : first rotation
left rotation complete
28
j
k
X V
ZW
i
Double rotation : second rotation
Now do a right rotation
29
jk
X V ZW
i
Double rotation : second rotation
right rotation complete
Balance has been restored
hh h or h-1
30
Implementation
balance (1,0,-1)
key
rightleft
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
31
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
32
Double Rotation
• Implement Double Rotation in two lines.
DoubleRotateFromRight(n : reference node pointer) {????}
X
n
V W
Z
33
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
34
Insert in BST
Insert(T : reference tree pointer, x : element) : integer {if T = null then T := new tree; T.data := x; return 1;//the links to //children are nullcase T.data = x : return 0; //Duplicate do nothing T.data > x : return Insert(T.left, x); T.data < x : return Insert(T.right, x);endcase}
35
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 > x : Insert(T.left, x); if ((height(T.left)- height(T.right)) = 2){ if (T.left.data > x ) then //outside case T = RotatefromLeft (T); else //inside case T = DoubleRotatefromLeft (T);} T.data < x : Insert(T.right, x); code similar to the left caseEndcase T.height := max(height(T.left),height(T.right)) +1; return;}
36
Example of Insertions in an AVL Tree
1
0
2
20
10 30
25
0
35
0
Insert 5, 40
37
Example of Insertions in an AVL Tree
1
0
2
20
10 30
25
1
35
0
50
20
10 30
25
1
355
40
0
0
01
2
3
Now Insert 45
38
Single rotation (outside case)
2
0
3
20
10 30
25
1
35
2
50
20
10 30
25
1
405
40
0
0
0
1
2
3
45
Imbalance35 45
0 0
1
Now Insert 34
39
Double rotation (inside case)
3
0
3
20
10 30
25
1
40
2
50
20
10 35
30
1
405
45
0 1
2
3
Imbalance
45
0
1
Insertion of 34
35
34
0
0
1 25 340
Extended Example
Insert 3,2,1,4,5,6,7, 16,15,14
41
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.
42
Deletion of a Node
• Deletion of a node x from an AVL tree requires the same basic ideas, including single and double rotations, that are used for insertion.
• With each node of the AVL tree is associated a balance factor that is left high, equal or right high according, respectively, as the left subtree has height greater than, equal to, or less than that of the right subtree.
43
Method
1. Reduce the problem to the case when the node x to be deleted has at most one child.
› If x has two children replace it with its immediate predecessor y under inorder traversal (the immediate successor would be just as good)
› Delete y from its original position, by proceeding as follows, using y in place of x in each of the following steps.
44
Method (cont.)
2. Delete the node x from the tree.› We’ll trace the effects of this change on height through all the
nodes on the path from x back to the root.› The action to be taken at each node depends on
• balance factor of the node• sometimes the balance factor of a child of the node.
45
Rebalancing the tree
Let p be the node whose balance factor becomes 2 or -2.› Rotation is needed.› Let q be the root of the taller subtree of p. We
have three cases according to the balance factor of q.
46
Case a
Case a: The balance factor of q is 0.› Apply a single rotation› Height of p is unchanged.
0 q
T3T2deleted
T1
-1 p
h-1
h h
1 q
T3
T2T1
-1 p
h-1h
h
height unchanged
47
Case bCase b: The balance factor of q is the same as that of
the previous balance factor of p.› Apply a single rotation› Set the balance factors of p and q to 0› Height of the subtree reduced .
-1q
T3T2deleted
T1
-1 p
h-1
h-1h
0q
T3
T1
0p
h-1h
height reduced
T2
h-1
48
Case cCase c: The previous balance factors of p and balance
factor of q are opposite.› Apply a double rotation› set the balance factors of the new root to 0› Height of subtree is reduced. height reduced
h-1T4
h-1q
T3T1
r
h-1T2
h-1 or h-2
p
0
1 q
T3
T1
r
h-1
T2
h-1 or h-2
p-1
T4
Delete 55
60
20 70
10 40 65 85
5 15 30 50 80 90
55
Delete 55
60
20 70
10 40 65 85
5 15 30 50 80 90
55
Delete 50
60
20 70
10 40 65 85
5 15 30 50 80 90
55
Delete 50
60
20 70
10 40 65 85
5 15 3050 80 90
55
Delete 60
60
20 70
10 40 65 85
5 15 30 50 80 90
55
prev
Delete 60
55
20 70
10 40 65 85
5 15 30 50 80 90
Delete 40
40
20 70
10 30 65 85
5 15 80 90
Delete 40
40
20 70
10 30 65 85
5 15 80 90
prev
Delete 40 : Rebalancing
30
20 70
10 65 85
5 15 80 90
Case ?
Delete 40: after rebalancing
30
7010
20 65 855
15 80 90
Single rotation is preferred!
59
Delete 20
30
20 55
10 25 45 60
15 5950
57
65
60
Delete 20
30
25 55
10 45 60
15 5950
57
65
61
Delete 20
30
15 55
10 45 6025
5950
57
65
62
Delete 20
55
30 60
15 59 6545
10 25 5750
63
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:4. Difficult to program & debug; more space for balance factor.5. Asymptotically faster but rebalancing costs time.6. Most large searches are done in database systems on disk and use
other structures (e.g. B-trees).7. 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
64
Double Rotation Solution
DoubleRotateFromRight(n : reference node pointer) {RotateFromLeft(n.right);RotateFromRight(n);}
X
n
V W
Z
top related