AVL树

 AVL树又称作高度平衡二叉树，它实际上是一种优化了的搜索二叉树。我们知道，由于二叉搜索树存在缺陷，有可能会退化成单链表，这样的话搜索的效率就降低了。为了将二叉搜索树的效率控制在O(logN)的级别，所以我们要给二叉搜索树加上一些条件，使得二叉搜索树高度平衡，时间复杂度为O(logN)。

概念：

1、首先AVL树是一颗二叉搜索树。

2、其次它的左子树和右子树都是AVL树。

3、它的左子树和右子树的高度差不超过1。(通常情况下，为每个结点都加一个平衡因子(bf)，这个平衡因子是右子树的高度减去左子树的高度)

例:

二、平衡化旋转

如果一棵树原来是平衡的二叉搜索树，现在向里面插入一个结点，造成了不平衡，这时候我们就要调整这棵树的结构，使之重新平衡。首先我们来看看造成不平衡的结构都有哪几种以及如何调整。

首先关于平衡我有以下几点需要强调一下：

1、如果插入一个结点，树的高度不变，则它就是平衡的。

2、旋转之后树的高度不变，这里的不变是指与插入之前的高度相同。

3、插入之后只会影响从插入点到根节点路径上的结点的平衡。

4、平衡因子的取值只可能是-2，-1,0,1,2，取-2或2时就出现不平衡了，这时就需要调整，调整之后树就平衡了。

5、注意，所有的插入都是建立在平衡二叉树的基础之上的。

关于左右双旋，他们的平衡因子有以下几种情况：

右左双旋与左右双旋是对称的，可参考左右双旋的出结论。

2、不仅是插入会破话树的平衡，删除也会破坏树的平衡，下面我们来分析一下删除的情况。首先必须明确删除只会影响从删除点到根节点路径上的结点，不会影响删除点之后的结点。 当然删除与二叉搜索树的删除一样，将删除结点有两个孩子的这种情况转换成只有一个孩子或者没有孩子的情况，然后再进行删除。当然删除之后树还要保持平衡。如果只有一个根节点的话直接删除就行。

[cpp]  view plain  copy

1. 代码：  
2. #pragma once  
3. #include<queue>  
4. using namespace std;  
5. template<typename K,typename V>  
6. struct AVLTreeNode  
7. {  
8.        K _key;  
9.        V _value;  
10.        int _bf;           //平衡因子，右子树的高度减去左子树的高度  
11.        AVLTreeNode<K, V> *_left;  
12.        AVLTreeNode<K, V> *_right;  
13.        AVLTreeNode<K, V> *_parent;  
14.        AVLTreeNode(K key, V value)  
15.               :_key(key)  
16.               , _value(value)  
17.               , _bf(0)  
18.               , _left(NULL)  
19.               , _right(NULL)  
20.               , _parent(NULL)  
21.        {}  
22. };  
23. template<typename K,typename V>  
24. class AVLTree  
25. {  
26.        typedef AVLTreeNode<K, V> Node;  
27. public:  
28.        AVLTree()  
29.               :_root(NULL)  
30.        {}  
31.        AVLTree(const AVLTree<K,V>& tree)  
32.               :_root(NULL)  
33.        {  
34.               _Copy(tree._root,_root);  
35.        }  
36.        AVLTree<K, V>& operator=(const AVLTree<K,V>& avl)  
37.        {  
38.               if (this != &avl)  
39.               {  
40.                      AVLTree<K, V> tmp(avl);  
41.                      swap(_root,tmp._root);  
42.               }  
43.               return *this;  
44.        }  
45.        ~AVLTree()  
46.        {  
47.               _Destory(_root);  
48.        }  
49.        bool Insert(const K& key,const V& value)  
50.        {  
51.               Node* cur = _root;  
52.               Node* parent = NULL;  
53.               while (cur)                        //寻找要插入的位置  
54.               {  
55.                      if (cur->_key < key)  
56.                      {  
57.                            parent = cur;  
58.                            cur = cur->_right;  
59.                      }  
60.                      else if (cur->_key>key)  
61.                      {  
62.                            parent = cur;  
63.                            cur = cur->_left;  
64.                      }  
65.                      else  
66.                            return false;             //如果已经存在就不插入  
67.               }  
68.               cur = new Node(key,value);  
69.               if (parent!=NULL)                 //树不是空树  
70.               {  
71.                      if (parent->_key < key)  
72.                            parent->_right = cur;  
73.                      else  
74.                            parent->_left = cur;  
75.                      cur->_parent = parent;  
76.               }  
77.               else                             //树是空树  
78.               {  
79.                      _root = cur;  
80.                      return true;  
81.               }  
82.               if (cur == parent->_left)        //如果插入的位置是父节点的左孩子  
83.                      parent->_bf--;  
84.               else  
85.                      parent->_bf++;               //如果插入的位置是父节点的右孩子  
86.               while (parent != NULL)             //沿着插入位置到根节点回溯，查找平衡因子不满足的结点  
87.               {  
88.                      if (parent->_bf == 0)          //表明插入之后parent这棵树的高度没变，因此这时就是AVL树  
89.                      {  
90.                            return true;  
91.                      }  
92.                      else if (parent->_bf == 1 || parent->_bf == -1)  //parent这棵树满足AVL,因为parent的高度发生变化，还要向上查找祖先结点  
93.                      {  
94.                            Node* ppNode = parent->_parent;      //保存parent的父节点  
95.                            if (ppNode != NULL)  
96.                            {  
97.                                   if (ppNode->_left == parent)      //ppNode的左子树高度发生变化  
98.                                          ppNode->_bf--;  
99.                                   else                              //ppNode的右子树高度发生变化  
100.                                          ppNode->_bf++;  
101.                            }  
102.                            parent = parent->_parent;      //当前树满足AVL树，所以继续向上判断  
103.                      }  
104.                      else          //如果当前树不满足AVL树，则就进行旋转恢复平衡  
105.                      {  
106.                            if (parent->_bf==2)          //如果parent的右子树高  
107.                            {  
108.                                   if (parent->_right->_bf == 1)      //parent一定不是叶子节点，所以他的孩子不为空  
109.                                          RotateL(parent);             //因为子树与parent一样都是右子树高，进行单左旋  
110.                                   else                       //parent的右子树高，它的孩子左子树高，右左双旋  
111.                                          RotateRL(parent);  
112.                            }  
113.                            else if(parent->_bf==-2)         //parent的左子树高度高  
114.                            {  
115.                                   if (parent->_left->_bf == -1)  //parent孩子的左子树高  
116.                                          RotateR(parent);          //右单旋  
117.                                   else                   //parent的左子树高，它的孩子右子树高，左右双旋  
118.                                          RotateLR(parent);  
119.                            }  
120.                            break;                      //旋转之后这棵树的高度恢复成原来的高度  
121.                      }  
122.               }  
123.               return true;  
124.        }  
125.        bool Remove(const K& key)  
126.        {  
127.               Node* parent = NULL;  
128.               Node* cur = _root;  
129.               Node* del = NULL;        //用来指向要删除的位置  
130.               while (cur)                  //寻找要删除的位置  
131.               {  
132.                      if (cur->_key < key)  
133.                      {  
134.                            cur = cur->_right;  
135.                      }  
136.                      else if (cur->_key>key)  
137.                      {  
138.                            cur = cur->_left;  
139.                      }  
140.                      else  
141.                            break;  
142.               }  
143.               if (cur == NULL)                 //删除失败  
144.                      return false;  
145.               del = cur;  
146.        //如果要删除的结点有两个孩子，则寻找右子树最左结点，将问题转换成只有一个孩子或没有孩子的形式  
147.               if (cur->_left != NULL&&cur->_right != NULL)  
148.               {  
149.                      cur = cur->_right;          //cur的右孩子一定不为空  
150.                      while (cur->_left)  
151.                      {  
152.                            cur = cur->_left;  
153.                      }  
154.                      del->_key = cur->_key;  
155.                      del->_value = cur->_value;  
156.                      del = cur;           //交换之后让del指向这个要删除的结点  
157.               }  
158.               parent = cur->_parent;        //让parent指向要删除的结点的父亲  
159.               if (cur->_left == NULL)       //要删除的结点的左孩子为空,或者都为空  
160.               {  
161.                      if (parent == NULL)  
162.                      {  
163.                            _root = cur->_right;  
164.                            if (cur->_right)           //如果cur有右孩子，则右孩子直接做根  
165.                                   cur->_right->_parent = NULL;  
166.                      }  
167.                      else  
168.                      {  
169.                            if (parent->_left == cur)  
170.                                   parent->_left = cur->_right;  
171.                            else  
172.                                   parent->_right = cur->_right;  
173.                            if (cur->_right)                    //cur的右子树不为空  
174.                                   cur->_right->_parent = parent;  
175.                      }  
176.                      cur = del->_right;           //cur更新到要删除结点的右子树  
177.               }  
178.               else                        //要删除的结点的右孩子为空，左孩子不为空  
179.               {  
180.                      if (parent == NULL)               //如果要删除的结点是头结点  
181.                            _root = cur->_left;  
182.                      else                                    //删除的结点不是根节点，则进行链接  
183.                      {  
184.                            if (parent->_left == cur)  
185.                                   parent->_left = cur->_left;  
186.                            else  
187.                                   parent->_right = cur->_left;  
188.                            cur->_left->_parent = parent;  
189.                      }  
190.                      cur = del->_left;            //cur更新到要删除结点的左子树  
191.               }  
192.               //因为要删除的结点之后的子树的高度不变，不需要修改，需要从parent向上判断是否平衡  
193.               while (parent)           //只要parent不为空，就有可能不平衡  
194.               {  
195.                      //调整parent的平衡因子  
196.                      if (parent->_left == cur)   //删除的是parent的左子树  
197.                            parent->_bf++;  
198.                      else  
199.                            parent->_bf--;  
200.                      if (parent->_bf == 1 || parent->_bf == -1) //原来平衡，删除一个后树高度不变，整棵树已经平衡  
201.                      {  
202.                            break;  
203.                      }  
204.                   //平衡因子原来不为0，删除一个高的子树之后变为0，需要继续向上寻找  
205.                      if (parent->_bf != 0)    //平衡因子原来不为0，且比较矮的子树被删除  
206.                      {  
207.                            if (cur == NULL)  
208.                            {  
209.                                   if (parent->_left == NULL)  
210.                                          cur = parent->_right;  
211.                                   else  
212.                                          cur = parent->_left;  
213.                            }  
214.                            else  
215.                            {  
216.                                   if (parent->_left == cur)   //原来parent的比较矮的左子树被删除,让cur指向较高的子树  
217.                                          cur = parent->_right;  
218.                                   else  
219.                                          cur = parent->_left;  
220.                            }  
221.                            if (cur->_bf == 0)       //cur的平衡因子为0，单旋转就可以平衡，而且parent这棵树的高度不变  
222.                            {  
223.                                   if (parent->_bf < 0)  //parent的左子树高，进行右旋转  
224.                                   {  
225.                                          RotateR(parent);        //parent旋转后指向这棵旋转子树的新根  
226.                                          parent->_bf=1;          
227.                                          parent->_right->_bf= -1;  
228.                                   }  
229.                                   else          //进行左旋转  
230.                                   {  
231.                                          RotateL(parent);  
232.                                          parent->_bf =-1;  
233.                                          parent->_left->_bf =1;  
234.                                   }  
235.                                   break;  
236.                            }  
237.                            //如果parent与较高的子树同号，则进行单旋转，旋转自后树的高度没有恢复成删除之前的，所以继续向上找  
238.                            int d = parent->_bf - cur->_bf;   //用d来判断是否同号，同号的话为1或-1，因为parent->_bf为2或-2，cur->_bf为1或-1  
239.                            if (d == 1 || d == -1)  
240.                            {  
241.                                   if (d == 1)       //右子树高，要进行左旋  
242.                                          RotateL(parent);  
243.                                   else  
244.                                          RotateR(parent);      //左子树高，进行右旋  
245.                            }  
246.                            else              //要双旋处理,因为异号，所以d为3或-3  
247.                            {  
248.                                   if (d == 3)       //parent->_bf为2，cur->_bf为-1,右左双旋  
249.                                          RotateRL(parent);  
250.                                   else  
251.                                          RotateLR(parent);  
252.                            }  
253.                      }  
254.                      cur = parent;  
255.                      parent = parent->_parent;  
256.               }  
257.               delete del;  
258.               return true;  
259.        }  
260.        bool Find(const K& key)  
261.        {  
262.               Node* cur = _root;  
263.               while (cur)  
264.               {  
265.                      if (cur->_key < key)  
266.                            cur = cur->_right;  
267.                      else if (cur->_key>key)  
268.                            cur = cur->_left;  
269.                      else  
270.                            return true;  
271.               }  
272.               return false;  
273.        }  
274.        void InOder()  
275.        {  
276.               _InOder(_root);  
277.        }  
278. protected:  
279.        void _Copy(Node* root,Node *&newroot)  
280.        {  
281.               if (root == NULL)  
282.                      return;  
283.               Node* node = new Node(root->_key, root->_value);  
284.               node->_bf = root->_bf;  
285.               newroot = node;  
286.               node->_parent = newroot;  
287.               _Copy(root->_left,newroot->_left);  
288.               _Copy(root->_right, newroot->_right);  
289.          
290.        }  
291.        void _Destory(Node* root)  
292.        {  
293.               if (root == NULL)  
294.                      return;  
295.               _Destory(root->_left);  
296.               _Destory(root->_right);  
297.               delete root;  
298.        }  
299.        void _InOder(Node* root)  
300.        {  
301.               if (root == NULL)  
302.                      return;  
303.               _InOder(root->_left);  
304.               cout << root->_key << " " << root->_bf << endl;  
305.               _InOder(root->_right);  
306.        }  
307.        void RotateL(Node *&parent)         //左单旋  
308.        {  
309.               Node* subR = parent->_right;  
310.               Node* subRL = subR->_left;  
311.               Node* ppNode = parent->_parent;      //保存parent的父节点  
312.               parent->_right = subRL;  
313.               if (subRL != NULL)  
314.                      subRL->_parent = parent;  
315.               subR->_left = parent;  
316.               parent->_parent = subR;  
317.               if (ppNode == NULL)  
318.               {  
319.                      _root = subR;  
320.                      subR->_parent = NULL;  
321.               }  
322.               else  
323.               {  
324.                      if (ppNode->_left == parent)  
325.                            ppNode->_left = subR;          //让旋转的这棵树的根节点重新与上层链接  
326.                      else  
327.                            ppNode->_right = subR;         //让旋转的这棵树的根节点重新与上层链接  
328.                      subR->_parent = ppNode;  
329.               }  
330.               parent->_bf = subR->_bf = 0;      //subR和parent又归于平衡  
331.               parent = subR;                   //让parent重新指向这棵树的根  
332.        }  
333.        void RotateR(Node * &parent)       //右单旋  
334.        {  
335.               Node* subL = parent->_left;          
336.               Node* subLR = subL->_right;  
337.               Node* ppNode = parent->_parent;      //保存parent的父节点  
338.               parent->_left = subLR;  
339.               if (subLR != NULL)  
340.                      subLR->_parent = parent;  
341.               subL->_right = parent;  
342.               parent->_parent = subL;  
343.                 
344.               if (ppNode == NULL)             //如果parent是空  
345.               {  
346.                      _root = subL;  
347.                      subL->_parent = NULL;  
348.               }  
349.               else  
350.               {  
351.                      if (ppNode->_left == parent)  
352.                            ppNode->_left = subL;                 //让旋转的这棵树的根节点重新与上层链接  
353.                      else  
354.                            ppNode->_right = subL;                  //让旋转的这棵树的根节点重新与上层链接  
355.                      subL->_parent = ppNode;  
356.               }  
357.               parent->_bf = subL->_bf=0;        //parent与subL又趋于平衡        
358.               parent = subL;                    //让parent重新指向这棵树的根  
359.        }  
360.        void RotateLR(Node *&parent)       //左右双旋  
361.        {  
362.               Node* tmp = parent->_left ;  
363.               Node* tmp2 = parent;  
364.               Node* subL = parent->_left;  
365.               Node* subLR = subL->_right;  
366.               int d1 = 0;  
367.               int d2 = 0;  
368.               if (subLR->_bf==1)        //右子树子树变高  
369.                      d1 =-1;  
370.               if (subLR->_bf == -1)       //左子树高  
371.                      d2 = 1;  
372.                 
373.               RotateL(tmp);  
374.               RotateR(tmp2);  
375.               subL->_bf = d1;  
376.               parent->_bf=d2;  
377.               parent = subLR;          //让parent重新指向这棵树的根  
378.        }  
379.        void RotateRL(Node* &parent)        //右左双旋  
380.        {  
381.               Node* tmp = parent->_right;  
382.               Node* tmp2 = parent;  
383.               Node* subR = parent->_right;       //记录subR和parent的平衡因子  
384.               Node* subRL = subR->_left;  
385.               int d1 = 0;  
386.               int d2 = 0;  
387.               if (subRL->_bf == -1)  
388.                      d1 = 1;  
389.               if (subRL->_bf == 1)  
390.                      d2 = -1;  
391.               RotateR(tmp);  
392.               RotateL(tmp2);  
393.               subR->_bf = d1;  
394.               parent->_bf = d2;  
395.               parent = subRL;         //让parent重新指向这棵树的根  
396.        }  
397. private:  
398.        Node* _root;  
399. };  

判断一颗搜索二叉树是不是AVL树，要求将时间优化到O(N).

思路：从根节点向上开始判断，并将高度传回上一层。

[cpp]  view plain  copy

1. bool IsBlance()  
2.     {  
3.         bool flag = false;  
4.         _IsBlance(_root,flag);  
5.         return flag;  
6.     }  
7.   
8.     int _IsBlance(Node* root, bool &flag)  
9.     {  
10.         if (root == NULL)  
11.         {  
12.             flag = true;  
13.             return 0;  
14.         }  
15.   
16.         int L=_IsBlance(root->_left,flag);  
17.         if (flag == false)  
18.             return 0;  
19.   
20.         int R=_IsBlance(root->_right,flag);  
21.         if (flag == false)  
22.             return 0;  
23.   
24.         if (abs(R - L) < 2)      //满足平衡条件  
25.         {  
26.             return L>R ? L + 1 : R + 1;  //返回高的子树高度+1  
27.         }  
28.         else  
29.             flag = false;  
30.         return 0;  
31.     }