AVL树探秘
一、AVL树
AVL树是一种平衡查找树，在前面的两篇文章：二叉搜索树 和 红黑树 中都提到过。由于二叉搜索树在某些特殊情况下是不平衡的（任意一个结点深度过大），因此其一些动态集合操作在最坏情况下的时间复杂度为O(n)。因此提出一些对二叉搜索树效率改进的树结构使最坏时间复杂度降为O(lgn)，AVL树和红黑树就是其中的代表，除此之外，还有一些如AA-tree、B-tree、2-3-tree等。使不平衡树变平衡最关键的是找到“平衡条件”，我们已经在前面一篇文章中详述了红黑树的平衡条件是：对节点进行着色，并约束从根节点到任何叶子节点的长度，其中，约定了5条规定，稍显复杂。而AVL树的平衡条件则显得格外简单：只用保证左右子树的高度不超过1即可。
二、AVL树的实现
1、数据结构
节点类：因为需要控制节点的高度，所以高度是一个属性。指针域包括left、right，parent可以包括也可以不要，本文的实现中，我们包括parent。
struct AVLNode {
AVLNode *Parent;
AVLNode *Left;
AVLNode *Right;
int m_nHeight;
int m_nValue;
};2、节点的平衡
当插入新的节点或者删除节点时，会导致树的不平衡，即其中有节点的左右子树的高度相差>1，这个时候就需要调节树使之平衡。可能出现不平衡的情况总共有以下几种：
////////////////////////////////////////
a a a a / / \ \ b b b b / \ / \ c c c c LL LR RL RR
//////////////////////////////////////
总共就只会出现这四种情况，对这四种情况的分类很多书上有各自的说法。其中1、4和2、3是对称的，我们用LL、LR、RL、RR来分别表示，要使这几种情况平衡，我们只用做简单的旋转操作就OK了，针对1、4，有的说法是做单旋，有的说法是外旋，而2、3，则做双旋或内旋，不管是哪种说法，其本质是不变的。在我们的实现中，采用单旋和双旋，双旋就是做两次单旋：
//单旋
void _LeftRotation( AVLNode *node );
void _RightRotation( AVLNode *node );
//双旋
void _LeftRightRotation( AVLNode *node );
void _RightLeftRotation( AVLNode *node );3、平衡的修复
在插入节点和删除节点的时候，会破坏树的平衡条件，这个时候就需要修复。我们采用尽可能少地改动原有代码的原则来修复，这个原则和红黑树的修复操作是一致的，即插入和删除操作我们依然沿用二叉搜索树的实现，只在后面添加修复的代码即可。
如何修复？首先，插入和删除会破坏节点的高度，所以，应更新结点的高度；其次，插入和删除破坏了树中某些节点的平衡，所以，应针对上面四种情况分别平衡节点。所以，这里就需要两个函数：一个更新结点高度的函数UpdateHeight( AVLNode *node )；一个平衡节点的函数： BalanceNode( AVLNode *node )。
void AVLTree::_UpdateHeight( AVLNode *node )
{
AVLNode *l = node->Left, *r = node->Right;
if ( l && r )
node->m_nHeight = max( l->m_nHeight, r->m_nHeight ) + 1;
else if ( l )
node->m_nHeight = l->m_nHeight + 1;
else if ( r )
node->m_nHeight = r->m_nHeight + 1;
else node->m_nHeight = 0;
} 1 //////////////////////////////////////////////////////////////////////////
2 // a a a a
3 // / / \ \
4 // b b b b
5 // / \ / \
6 // c c c c
7 // LL LR RL RR
8 //////////////////////////////////////////////////////////////////////////
9 void AVLTree::_BalanceNode( AVLNode *node )
10 {
11 int nBlance = _GetBalanceFactor( node );
12 if ( nBlance > 1 ) { //L
13 //(1)
14 //if ( _GetBalanceFactor( node->Left ) < 0 ) //LR
15 // _LeftRightRotation( node ); //双旋
16 //else _RightRotation( node ); //LL //单旋
17
18 //(2)
19 if ( _GetBalanceFactor( node->Left ) < 0 )
20 _LeftRotation( node->Left );
21 _RightRotation( node );
22 }
23 if ( nBlance < -1 ) { //R
24 if ( _GetBalanceFactor( node ) > 0 ) { //RL
25 _RightRotation( node->Right );
26 }
27 _LeftRotation( node );
28 }
29 }
30
31 //平衡因子(左右子树的高度差)
32 int AVLTree::_GetBalanceFactor( AVLNode *node )
33 {
34 AVLNode *l = node->Left, *r = node->Right;
35
36 if ( l && r )
37 return l->m_nHeight - r->m_nHeight;
38 else if ( l )
39 return l->m_nHeight + 1;
40 else if ( r )
41 return -r->m_nHeight - 1;
42 else return 0;
43 }基本上该注意的点都提到了，下面附上详细代码实现：
1 #ifndef __AVL_TREE_H_
2 #define __AVL_TREE_H_
3
4 class AVLTree
5 {
6 private:
7 struct AVLNode {
8 AVLNode *Parent;
9 AVLNode *Left;
10 AVLNode *Right;
11 int m_nHeight;
12 int m_nValue;
13 };
14 public:
15 AVLTree(AVLNode *root = NULL):m_pRoot(root) {}
16 ~AVLTree() {
17 _RecursiveDeleteNode(m_pRoot);
18 }
19
20 bool Search( const int search_value ) const;
21 bool Insert( const int value );
22 bool Delete( const int delete_value );
23
24 void Print() const;
25
26 private:
27 void _RecursiveDeleteNode(AVLNode *node) {
28 if ( node ) {
29 _RecursiveDeleteNode( node->Left );
30 _RecursiveDeleteNode( node->Right );
31 delete node;
32 }
33 node = NULL;
34 }
35
36 void _DeleteNode( AVLNode *delete_node );
37 void _Delete_Transplant( AVLNode *unode, AVLNode *vnode );
38 void _InsertNode( const int insert_value );
39 AVLNode * _SearchNode( AVLNode *node, const int search_value ) const;
40
41 //单旋
42 void _LeftRotation( AVLNode *node );
43 void _RightRotation( AVLNode *node );
44
45 //双旋
46 void _LeftRightRotation( AVLNode *node );
47 void _RightLeftRotation( AVLNode *node );
48
49 AVLNode* Minimum( AVLNode *node );
50
51 //树高
52 int _Height ( AVLNode *node );
53 void _UpdateHeight( AVLNode *node );
54 //平衡因子
55 int _GetBalanceFactor( AVLNode *node );
56 //平衡失去平衡的节点
57 void _BalanceNode( AVLNode *node );
58
59 void _Print ( AVLNode *node ) const;
60
61 private:
62 AVLNode *m_pRoot;
63
64 };
65 #endif//__AVL_TREE_H_ 1 #include <iostream>
2 #include <algorithm>
3 using namespace std;
4
5 #include "AVL_Tree.h"
6
7 bool AVLTree::Search( const int search_value ) const
8 {
9 return _SearchNode( m_pRoot, search_value ) != NULL;
10 }
11
12 AVLTree::AVLNode * AVLTree::_SearchNode( AVLNode *node, const int search_value ) const
13 {
14 while ( node && search_value != node->m_nValue ) {
15 if ( search_value < node->m_nValue )
16 node = node->Left;
17 else
18 node = node->Right;
19 }
20 return node;
21 }
22
23 bool AVLTree::Insert( const int value )
24 {
25 //该值已存在
26 if ( Search( value ) )
27 return false;
28 else {
29 _InsertNode( value );
30 return true;
31 }
32 }
33
34 void AVLTree::_InsertNode( const int insert_value )
35 {
36 AVLNode *node = m_pRoot;
37 AVLNode *temp_node = NULL;
38
39 //先找到待插入节点的位置
40 while ( node ) {
41 temp_node = node;
42 node = ( insert_value < node->m_nValue )?node->Left:node->Right;
43 }
44
45 AVLNode *insert_node = new AVLNode();
46 insert_node->m_nValue = insert_value;
47
48 insert_node->Parent = temp_node;
49
50 //空树
51 if ( temp_node == NULL )
52 m_pRoot = insert_node;
53 else {
54 if ( insert_value < temp_node->m_nValue )//左子树
55 temp_node->Left = insert_node;
56 else
57 temp_node->Right = insert_node; //右子树
58 }
59
60 //更新插入节点的高度和平衡节点
61 while ( insert_node ) {
62 _UpdateHeight( insert_node );
63 _BalanceNode( insert_node );
64 insert_node = insert_node->Parent;
65 }
66 }
67
68 bool AVLTree::Delete( const int delete_value )
69 {
70 AVLNode *delete_node = _SearchNode( m_pRoot, delete_value );
71
72 //节点不存在
73 if ( delete_node == NULL )
74 return false;
75 else {
76 _DeleteNode( delete_node );
77 return true;
78 }
79 }
80
81 void AVLTree::_DeleteNode( AVLNode *delete_node )
82 {
83 if ( delete_node->Left == NULL )
84 _Delete_Transplant( delete_node, delete_node->Right );
85 else if ( delete_node->Right == NULL )
86 _Delete_Transplant( delete_node, delete_node->Left );
87 else {
88 AVLNode *min_node = Minimum( delete_node->Right );
89 if ( min_node->Parent != delete_node ) {
90 _Delete_Transplant( min_node, min_node->Right );
91 min_node->Right = delete_node->Right;
92 min_node->Right->Parent = min_node;
93 }
94 _Delete_Transplant( delete_node, min_node );
95 min_node->Left = delete_node->Left;
96 min_node->Left->Parent = min_node;
97 }
98
99 //更新结点的高度和平衡节点
100 while ( delete_node ) {
101 _UpdateHeight( delete_node );
102 _BalanceNode( delete_node );
103 delete_node = delete_node->Parent;
104 }
105 }
106
107 void AVLTree::_Delete_Transplant( AVLNode *unode, AVLNode *vnode )
108 {
109 if ( unode->Parent == NULL )
110 m_pRoot = vnode;
111 else if ( unode == unode->Parent->Left )
112 unode->Parent->Left = vnode;
113 else
114 unode->Parent->Right = vnode;
115 if ( vnode )
116 vnode->Parent = unode->Parent;
117 }
118
119 AVLTree::AVLNode* AVLTree::Minimum( AVLNode *node )
120 {
121 while ( node->Left )
122 node = node->Left;
123 return node;
124 }
125
126 //树高
127 int AVLTree::_Height( AVLNode *node )
128 {
129 return node->m_nHeight;
130 }
131
132 //平衡因子(左右子树的高度差)
133 int AVLTree::_GetBalanceFactor( AVLNode *node )
134 {
135 AVLNode *l = node->Left, *r = node->Right;
136
137 if ( l && r )
138 return l->m_nHeight - r->m_nHeight;
139 else if ( l )
140 return l->m_nHeight + 1;
141 else if ( r )
142 return -r->m_nHeight - 1;
143 else return 0;
144 }
145
146 void AVLTree::_UpdateHeight( AVLNode *node )
147 {
148 AVLNode *l = node->Left, *r = node->Right;
149
150 if ( l && r )
151 node->m_nHeight = max( l->m_nHeight, r->m_nHeight ) + 1;
152 else if ( l )
153 node->m_nHeight = l->m_nHeight + 1;
154 else if ( r )
155 node->m_nHeight = r->m_nHeight + 1;
156 else node->m_nHeight = 0;
157 }
158
159 //////////////////////////////////////////////////////////////////////////
160 // a a a a
161 // / / \ \
162 // b b b b
163 // / \ / \
164 // c c c c
165 // LL LR RL RR
166 //////////////////////////////////////////////////////////////////////////
167 void AVLTree::_BalanceNode( AVLNode *node )
168 {
169 int nBlance = _GetBalanceFactor( node );
170 if ( nBlance > 1 ) { //L
171 //(1)
172 //if ( _GetBalanceFactor( node->Left ) < 0 ) //LR
173 // _LeftRightRotation( node ); //双旋
174 //else _RightRotation( node ); //LL //单旋
175
176 //(2)
177 if ( _GetBalanceFactor( node->Left ) < 0 )
178 _LeftRotation( node->Left );
179 _RightRotation( node );
180 }
181 if ( nBlance < -1 ) { //R
182 if ( _GetBalanceFactor( node ) > 0 ) { //RL
183 _RightRotation( node->Right );
184 }
185 _LeftRotation( node );
186 }
187 }
188
189 //单旋
190 //左旋
191 void AVLTree::_LeftRotation( AVLNode *node )
192 {
193 if ( node->Right == NULL )
194 return;
195
196 AVLNode *temp_node = node->Right;
197
198 //补
199 node->Right = temp_node->Left;
200 if ( temp_node->Left )
201 temp_node->Left->Parent = node;
202
203 //提
204 temp_node->Parent = node->Parent;
205 if ( node->Parent == NULL )
206 m_pRoot = temp_node;
207 else if ( node == node->Parent->Left )
208 node->Parent->Left = temp_node;
209 else node->Parent->Right = temp_node;
210
211 //降
212 temp_node->Left = node;
213 node->Parent = temp_node;
214
215 _UpdateHeight( node );
216 _UpdateHeight( temp_node );
217 }
218
219 //右旋
220 void AVLTree::_RightRotation( AVLNode *node )
221 {
222 if ( node->Left == NULL )
223 return;
224
225 AVLNode *temp_node = node->Left;
226
227 //补
228 node->Left = temp_node->Right;
229 if ( temp_node->Right )
230 temp_node->Right->Parent = node;
231
232 //提
233 temp_node->Parent = node->Parent;
234 if ( node->Parent == NULL )
235 m_pRoot = temp_node;
236 else if ( node == node->Parent->Left )
237 node->Parent->Left = temp_node;
238 else node->Parent->Right = temp_node;
239
240 //降
241 temp_node->Right = node;
242 node->Parent = temp_node;
243
244 _UpdateHeight( node );
245 _UpdateHeight( temp_node );
246 }
247
248 //双旋
249 //LR
250 void AVLTree::_LeftRightRotation( AVLNode *node )
251 {
252 _LeftRotation( node->Left );
253 _RightRotation( node );
254 }
255
256 //RL
257 void AVLTree::_RightLeftRotation( AVLNode *node )
258 {
259 _RightRotation( node->Right );
260 _RightRotation( node );
261 }
262
263 void AVLTree::Print() const
264 {
265 _Print(m_pRoot);
266 }
267 //打印
268 void AVLTree::_Print ( AVLNode *node ) const
269 {
270 if ( node->Parent == NULL )
271 cout << "root: " << node->m_nValue << endl;
272 else if ( node == node->Parent->Left )
273 cout << "left: " << node->m_nValue << ", parent: " << node->Parent->m_nValue << endl;
274 else cout << "right: " << node->m_nValue << ", parent: " << node->Parent->m_nValue << endl;
275 if ( node->Left )
276 _Print( node->Left );
277 if ( node->Right )
278 _Print( node->Right );
279 }
280
281 int main()
282 {
283 AVLTree al;
284 for (int i = 1; i < 10; i ++) {
285 al.Insert(i);
286
287 }
288 al.Print();
289 for (int i = 1; i < 10; i += 2) {
290 al.Delete(i);
291 al.Print();
292 }
293 return 0;
294 }本文参与 腾讯云自媒体分享计划，分享自作者个人站点/博客。
原始发表：2015-11-02 ，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读