AVL ํธ๋ฆฌ๋ ์ด์ ์๊ฐ์ ๋ดค๋๊ฒ ์ฒ๋ผ ์ผ๋ฐ ์ด์ง ๊ฒ์ ํธ๋ฆฌBST์ 'ํ์ '์ด๋ผ๋ ๊ณผ์ ์ ํต
ํด ์ฝ์
๊ณผ ์ญ์ ํ์ ๋์ด์ ์ฐจ์ด๋ฅผ k=1 ์ดํ๊ฐ ๋๋๋ก ์กฐ์ ํ๋ ์ฐ์ฐ์ด ์ถ๊ฐ๋ ํธ๋ฆฌ๋ค.
ํ์
AVL ์กฐ๊ฑด์ ์๋ฐฐ?
์ฝ์
ํน์ ์ญ์ ํ์ AVLํธ๋ฆฌ์ ์กฐ๊ฑด์ด ์๋ฐฐ๋์๋ค๊ณ ํ๋ค๋๊ฒ์ k๊ฐ ์ ํํ 2๊ฐ ๋์๋ค๋ ๋ง์ด๋ค.
์ฝ์ ์ดํ ํ์
์ฝ์ ์ดํ์ AVL ํธ๋ฆฌ์ ์์ฑ์ ํ๋ณตํ๋ ค๋ฉด ์ฝ์ ์ง์ ์์ ์์ํด ๋ฃจํธ๊น์ง ์ด๋ํ๋ฉด์ AVL ์์ฑ์ ๋ง์กฑ์ํค์ง ์๋ ์ฒซ ๋ฒ์งธ ๋ ธ๋๊ฐ ๋ฌด์์ธ์ง ์ฐพ๋๋ค.
์ด ๋ ธ๋๋ฅผ X๋ผ๊ณ ํ์. ์ด ๋ ๋ฐ์ํ ์ ์๋ ๊ฒฝ์ฐ๋ ์ด ๋ค ๊ฐ์ง๋ค.
- X์ ์ผ์ชฝ ์์์ ์ผ์ชฝ ์๋ธํธ๋ฆฌ์ ๋ ธ๋๊ฐ ์ฝ์ ๋ ๊ฒฝ์ฐ (LL)
- X์ ์ผ์ชฝ ์์์ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ์ ๋ ธ๋๊ฐ ์ฝ์ ๋ ๊ฒฝ์ฐ (LR)
- X์ ์ค๋ฅธ์ชฝ ์์์ ์ผ์ชฝ ์๋ธํธ๋ฆฌ์ ๋ ธ๋๊ฐ ์ฝ์ ๋ ๊ฒฝ์ฐ (RL)
- X์ ์ค๋ฅธ์ชฝ ์์์ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ์ ๋
ธ๋๊ฐ ์ฝ์
๋ ๊ฒฝ์ฐ (RR)
1๋ฒ๊ณผ 4๋ฒ์ ๊ฒฝ์ฐ์๋ ํ์ ํ ๋ฒ์ ํตํด ์๋ฃ๋์ง๋ง, 2๋ฒ๊ณผ 3๋ฒ์ ๊ฒฝ์ฐ์๋ ๋ ๋ฒ์ ํ์ ์ ์ฌ์ฉํด์ผ ํ๋ค.
๋จ์ ํ์
LL ํ์
9
8
7
7์ด ๋ฐฉ๊ธ ์ฝ์
๋ ๋
ธ๋๋ผ๋ฉด X๋
ธ๋๋ ๋ฌด์์ผ๊น?
8์ 1 - 0 = 1 ์ผ๋ก ๋ฌธ์ ๊ฐ ์๊ณ , 9๋ 2-0 = 2 ๋ก k๊ฐ 1๋ณด๋ค ์ปค์ ธ์ 9๊ฐ ์ฒซ ๋
ธ๋ X๊ฐ ๋๋ค.
9 ๋
ธ๋์์ LL ํ์ ์ ์ํํ๋ค.
8
7 9
๊ทธ๋ฐ๋ฐ ๊ฐ ๋ ธ๋๋ค์ด ์๋ธํธ๋ฆฌ๋ฅด ๊ฐ์ง๋ ๊ฒฝ์ฐ์๋ ์ด๋กํ ๊น?
9
8 10
7 8.5
6
์ด๋ ๊ฒ 8.5
์ 10
์ด ์์ผ๋ฉด?
8.5
๋ฅผ 9
์ ์ผ์ชฝ์ ์์น์ํจ๋ค.
๊ตฌ์ฒด์ ์ธ ์ฝ๋๋ ์ด๋ ๋ค.
struct AVLTreeNode *SingleRotateRight(struct AVLTreeNode *x) {
struct AVLTreeNode *w = x->left;
x->left = w->right;
w->right = x;
x->height = max(height(x->left),height(x->right))+1;
w->height = max(height(w->left),x->height)+1;
return w;
}
w->right
๋ w๋ณด๋ค ํฌ๋ฉด์ x๋ณด๋ค ์๊ธฐ ๋๋ฌธ์x->left
๋ก ์ค๋ฉด ๋๊ณ ,w->right
๋ฅผ x๋ก ๋ณ๊ฒฝ. (x->right
์w->left
๋ ๋ณํ์ง ์๋๋ค.)- ๊ทธ๋ฆฌ๊ณ x์ w์ ๋์ด๋ฅผ ์ ๋ฐ์ดํธ ํ๋ค.
RR ํ์
LL๊ณผ ์ ์ฌํ๋ฐ ์ฐจ์ด์ ์ด๋ผ๋ฉด w๋์ y(x์ ์ค๋ฅธ์ชฝ์ ์๋ ์ํ๋ฒณ์ด๋ผ)์ ์ฌ์ฉํ๊ณ ,
x->left
๋์ x->right
์ w->right
๋์ y->left
๋ฅผ ๋ณ๊ฒฝํ๋ค๋ ๊ฒ์ด๋ค. (์ ํํ LL์ด ๋ณ๊ฒฝํ์ง ์๋ ๋
ธ๋๋ฅผ ๋ณ๊ฒฝ)
struct AVLTreeNode *SingleRotateLeft(struct AVLTreeNode *x) {
struct AVLTreeNode *y = x->right;
x->right = y->left;
y->left = x;
x->height = max(height(x->left),height(x->right))+1;
y->height = max(height(y->right),x->height)+1;
return y;
}
๋จ์ ํ์ single rotation์ ๊ฒฝ์ฐ์๋ LL์ด๋ RR ๋ชจ๋ ์ค์ ๋ก ์ค์ํ๊ฒ ๋ค๋ค์ง๋ ์๋ธํธ๋ฆฌ๋ LL์ ๊ฒฝ์ฐ LR(
w->right
) ์ชฝ ํธ๋ฆฌ์ด๊ณ RR์ ๊ฒฝ์ฐ RL(y->left
) ์ชฝ ํธ๋ฆฌ๋ค. ๊ฐ ์๋ธํธ๋ฆฌ๋ค์ ๊ธฐ์กด ๋ฃจํธ x์ ๋ถ์ฌ์ค๋ค.
์ด์ค ํ์
์ด์ค ํ์ ์ RLํธ๋ฆฌ์ LR ํธ๋ฆฌ์ ์ฝ์
์ด ๋ฐ์ํ ํ์ AVL ์กฐ๊ฑด์ ์๋ฐฐํ๊ฒ ๋ ๋ ์คํ๋๋ค.
'์ด์คdouble'์ด๋ผ๋ ๋ง์ฒ๋ผ ๋จ์ผ ํ์ ์ ๋ ๋ฒ ๋ฐ๋ณตํ๋ฉด ๋๋๋ฐ LL์ ๊ฒฝ์ฐ๋ RRํ์ ํ์ LLํ์ , RL์ ๊ฒฝ์ฐ์๋ LLํ์ ํ์ RR ํ์ .
// LR
struct AVLTreeNode *DoubleRotationLeft(struct AVLTreeNode *x){
x->left = SingleRotateLeft(x->left);
return SingleRotateRight(x);
}
// RL
struct AVLTreeNode *DoubleRotationLeft(struct AVLTreeNode *x){
x->right = SingleRotateRight(x->right);
return SingleRotateLeft(x);
}