Cy AVL

nh gi tm kim
1
1, 2, 3, 4, 5
1
2
3
4
5
Cy AVL
Gii thiu AVL Tree
Phng php chn trn CNPTK c th c nhng bin dng
mt cn i nghim trng
Chi ph cho vic tm kim trong trng hp xu nht t ti n
VD: 1 triu nt chi ph tm kim = 1.000.000 nt

Nu c mt cy tm kim nh phn cn bng hon ton, chi
ph cho vic tm kim ch xp x log
2
n
VD: 1 triu nt chi ph tm kim = log
2
1.000.000 20 nt

G.M. Adelson-Velsky v E.M. Landis xut mt tiu
chun cn bng (sau ny gi l cn bng AVL)
Cy AVL c chiu cao O(log
2
(n))
2
Cy AVL
AVL Tree - nh ngha
3
Cy nh phn tm kim cn bng (AVL) l cy m ti mi nt
cao ca cy con tri v ca cy con phi chnh lch khng
qu mt

44
23 88
13 37 59 108
15 30 40 55 71
Cy AVL
AVL Tree V d
4
AVL Tree ?
AVL Tree?
Cy AVL
AVL Tree
Ch s cn bng ca mt nt:
nh ngha: Ch s cn bng ca mt nt l hiu ca chiu cao
cy con phi v cy con tri ca n
i vi mt cy cn bng, ch s cn bng (CSCB) ca mi nt
ch c th mang mt trong ba gi tr sau y:
CSCB(p) = 0 cao cy phi (p) = cao cy tri (p)
CSCB(p) = 1 cao cy phi (p) > cao cy tri (p)
CSCB(p) = -1 cao cy phi (p) < cao cy tri (p)
5
Cy AVL
V d - Ch s cn bng ca nt
What is the balance factor for each node in this AVL tree?
Is this an AVL tree?
1
-1
0
0 0
0
-1
-1
1
0
1
0
0
10
40
30 45
20 35
25
60
7
3 8
1 5
Cy AVL
AVL Tree V d
7
Cy AVL
AVL Tree Biu din
8
#define RH 1 /* Cy con phi cao hn */
#define EH 0 /* Hai cy con bng nhau */
#define LH -1 /* Cy con tri cao hn */

struct AVLNode{
char balFactor; // Ch s cn bng
DataType data;
AVLNode* pLeft;
AVLNode* pRight;
};
typedef AVLNode* AVLTree;
Cy AVL
AVL Tree Biu din
9
Cc thao tc c trng ca cy AVL:
Thm mt phn t vo cy AVL
Hy mt phn t trn cy AVL
Cn bng li mt cy va b mt cn bng (Rotation)
Trng hp thm mt phn t trn cy AVL c thc hin
ging nh thm trn CNPTK, tuy nhin sau khi thm phi cn
bng li cy
Trng hp hy mt phn t trn cy AVL c thc hin
ging nh hy trn CNPTK v cng phi cn bng li cy
Vic cn bng li mt cy s phi thc hin sao cho ch nh
hng ti thiu n cy nhm gim thiu chi ph cn bng

Cy AVL
AVL Tree - Cc trng hp mt cn bng
Khng kho st tnh cn bng ca 1 cy nh phn bt k m
ch quan tm n kh nng mt cn bng xy ra khi chn hoc
xa mt nt trn cy AVL
Cc trng hp mt cn bng:
Sau khi chn (xa) cy con tri lch tri (left of left)
Sau khi chn (xa) cy con tri lch phi (right of left)
Sau khi chn (xa) cy con phi lch phi (right of right)
Sau khi chn (xa) cy con phi lch tri (left of right)


10
Cy AVL
V d: Cc trng hp mt cn bng

Cy AVL
V d: Cc trng hp mt cn bng

Cy AVL
AVL Tree - Cc trng hp mt cn bng
Chn nt vo cy AVL









1 v 4 l cc nh i xng
2 v 3 l cc nh i xng
1 2 3 4
Cy AVL
Cy AVL Ti cn bng
Trng hp 1 c gii bi php quay:









Trng hp 4 l quay mt nh i xng

Cy AVL
Cy AVL Ti cn bng
Trng hp 2 cn mt php quay kp (double)








Trng hp 3 l php quay nh i xng

Cy AVL
V d: Ti cn bng
16
1. left of left
Cy AVL
17
V d: Ti cn bng
2. right of left
Cy AVL
18
V d: Ti cn bng
3. right of right
Cy AVL
19
V d: Ti cn bng
4. left of right
Cy AVL
AVL Tree - Cn bng li cy AVL
32
void rotateLL(AVLTree &T) //quay n Left-Left
{
AVLNode* T1 = T->pLeft;
T->pLeft = T1->pRight;
T1->pRight = T;
switch(T1->balFactor) {
case LH: T->balFactor = EH;
T1->balFactor = EH;
break;
case EH: T->balFactor = LH;
T1->balFactor = RH;
break;
}
T = T1;
}
Quay n Left-Left:
Cy AVL
AVL Tree - Cn bng li cy AVL
33
Quay n Right-Right:
void rotateRR (AVLTree &T) //quay n Right-Right
{
AVLNode* T1 = T->pRight;
T->pRight = T1->pLeft;
T1->pLeft = T;
switch(T1->balFactor) {
case RH: T->balFactor = EH;
T1->balFactor= EH;
break;
case EH: T->balFactor = RH;
T1->balFactor= LH;
break;
}
T = T1;
}
Cy AVL
AVL Tree - Cn bng li cy AVL
34
Quay kp Left-Right:
void rotateLR(AVLTree &T)//quay kp Left-Right
{ AVLNode* T1 = T->pLeft;
AVLNode* T2 = T1->pRight;
T->pLeft = T2->pRight;
T2->pRight = T;
T1->pRight = T2->pLeft;
T2->pLeft = T1;
switch(T2->balFactor) {
case LH: T->balFactor = RH; T1->balFactor = EH; break;
case EH: T->balFactor = EH; T1->balFactor = EH; break;
case RH: T->balFactor = EH; T1->balFactor = LH; break;
}
T2->balFactor = EH;
T = T2;
}
Cy AVL
AVL Tree - Cn bng li cy AVL
35
Quay kep Right-Left
void rotateRL(AVLTree &T) //quay kp Right-Left
{ AVLNode* T1 = T->pRight;
AVLNode* T2 = T1->pLeft;
T->pRight = T2->pLeft;
T2->pLeft = T;
T1->pLeft = T2->pRight;
T2->pRight = T1;
switch(T2->balFactor) {
case RH: T->balFactor = LH; T1->balFactor = EH; break;
case EH: T->balFactor = EH; T1->balFactor = EH; break;
case LH: T->balFactor = EH; T1->balFactor = RH; break;
}
T2->balFactor = EH;
T = T2;
}
Cy AVL
AVL Tree - Cn bng li cy AVL
36
Cn bng khi cy b lch v bn tri:
int balanceLeft(AVLTree &T)
//Cn bng khi cy b lch v bn tri
{
AVLNode* T1 = T->pLeft;

switch(T1->balFactor) {
case LH: rotateLL(T); return 2;
case EH: rotateLL(T); return 1;
case RH: rotateLR(T); return 2;
}
return 0;
}
Cy AVL
AVL Tree - Cn bng li cy AVL
37
Cn bng khi cy b lch v bn phi
int balanceRight(AVLTree &T )
//Cn bng khi cy b lch v bn phi
{
AVLNode* T1 = T->pRight;

switch(T1->balFactor) {
case LH: rotateRL(T); return 2;
case EH: rotateRR(T); return 1;
case RH: rotateRR(T); return 2;
}
return 0;
}
Cy AVL
AVL Tree - Thm mt phn t trn cy AVL
Vic thm mt phn t vo cy AVL din ra tng t nh trn
CNPTK
Sau khi thm xong, nu chiu cao ca cy thay i, t v tr
thm vo, ta phi ln ngc ln gc kim tra xem c nt
no b mt cn bng khng. Nu c, ta phi cn bng li nt
ny
Vic cn bng li ch cn thc hin 1 ln ti ni mt cn bng
Hm insertNode tr v gi tr 1, 0, 1 khi khng b nh,
gp nt c hay thnh cng. Nu sau khi thm, chiu cao cy b
tng, gi tr 2 s c tr v
int insertNode(AVLTree &T, DataType X)
38
Cy AVL
AVL Tree - Thm mt phn t trn cy AVL
int insertNode(AVLTree &T, DataType X)
{ int res;
if (T)
{ if (T->key == X) return 0; // c
if (T->key > X)
{ res = insertNode(T->pLeft, X);
if(res < 2) return res;
switch(T->balFactor)
{ case RH: T->balFactor = EH; return 1;
case EH: T->balFactor = LH; return 2;
case LH: balanceLeft(T); return 1;
}
}
......................................................
}
39
insertNode2
Cy AVL
AVL Tree - Thm mt phn t trn cy AVL
int insertNode(AVLTree &T, DataType X)
{
......................................................
else // T->key < X
{ res = insertNode(T-> pRight, X);
if(res < 2) return res;
switch(T->balFactor)
{ case LH: T->balFactor = EH; return 1;
case EH: T->balFactor = RH; return 2;
case RH: balanceRight(T); return 1;
}
}
......................................................
}
40
insertNode3
Cy AVL
AVL Tree - Thm mt phn t trn cy AVL
int insertNode(AVLTree &T, DataType X)
{
...........................................
...........
T = new TNode;
if(T == NULL) return -1; //thiu b nh
T->key = X;
T->balFactor = EH;
T->pLeft = T->pRight = NULL;
return 2; // thnh cng, chiu cao tng
}
41
Cy AVL
AVL Tree - Hy mt phn t trn cy AVL
Cng ging nh thao tc thm mt nt, vic hy mt phn t
X ra khi cy AVL thc hin ging nh trn CNPTK
Sau khi hy, nu tnh cn bng ca cy b vi phm ta s thc
hin vic cn bng li
Tuy nhin vic cn bng li trong thao tc hy s phc tp hn
nhiu do c th xy ra phn ng dy chuyn
Hm delNode tr v gi tr 1, 0 khi hy thnh cng hoc
khng c X trong cy. Nu sau khi hy, chiu cao cy b gim,
gi tr 2 s c tr v:
int delNode(AVLTree &T, DataType X)

42
Cy AVL
AVL Tree - Hy mt phn t trn cy AVL
int delNode(AVLTree &T, DataType X)
{ int res;
if(T==NULL) return 0;
if(T->key > X)
{ res = delNode (T->pLeft, X);
if(res < 2) return res;
switch(T->balFactor)
{ case LH: T->balFactor = EH; return 2;
case EH: T->balFactor = RH; return 1;
case RH: return balanceRight(T);
}
} // if(T->key > X)
......................................................
}
43
delNode2
Cy AVL
AVL Tree - Hy mt phn t trn cy AVL
int delNode(AVLTree &T, DataType X)
{
......................................................
if(T->key < X)
{ res = delNode (T->pRight, X);
if(res < 2) return res;
switch(T->balFactor)
{ case RH: T->balFactor = EH; return 2;
case EH: T->balFactor = LH; return 1;
case LH: return balanceLeft(T);
}
} // if(T->key < X)
......................................................
}
44
delNode3
Cy AVL
AVL Tree - Hy mt phn t trn cy AVL
int delNode(AVLTree &T, DataType X)
{......................................................
else //T->key == X
{ AVLNode* p = T;
if(T->pLeft == NULL) { T = T->pRight; res = 2; }
else if(T->pRight == NULL) { T = T->pLeft; res = 2; }
else //T c c 2 con
{ res = searchStandFor(p,T->pRight);
if(res < 2) return res;
switch(T->balFactor)
{ case RH: T->balFactor = EH; return 2;
case EH: T->balFactor = LH; return 1;
case LH: return balanceLeft(T);
}
}
delete p; return res;
}
}
45
Cy AVL
AVL Tree - Hy mt phn t trn cy AVL
int searchStandFor(AVLTree &p, AVLTree &q)
//Tm phn t th mng
{ int res;
if(q->pLeft)
{ res = searchStandFor(p, q->pLeft);
if(res < 2) return res;
switch(q->balFactor)
{ case LH: q->balFactor = EH; return 2;
case EH: q->balFactor = RH; return 1;
case RH: return balanceRight(T);
}
} else
{ p->key = q->key; p = q; q = q->pRight; return 2;
}
}

46