各种折腾...

  1 #include <iostream>
  2 #define MAX(a,b) ((a)>(b)?(a):(b))
  3 #define SIZEOFARRY(a) sizeof(a)/sizeof(int)
  4 #define ASSERT(a) if((a)==NULL)exit(0)
  5 
  6 using namespace std;
  7 
  8 typedef  int Datatype;
  9 
 10 typedef struct AVLTNode
 11 {
 12     struct AVLTNode*    pLeft;
 13     struct AVLTNode*    pRight;
 14     int                height;
 15     Datatype        data;
 16 }*pNode;
 17 
 18 typedef struct AVLTNode* Tree;
 19 
 20 
 21 class AVLTree
 22 {
 23 public:
 24     AVLTree(){root=NULL;}
 25     ~AVLTree(){}
 26     void InsertNode(Datatype x){root=InsertNode(x,root);};
 27     void DeleteNode(Datatype x){root = DeleteNode(x, root);};
 28     void PrintTreeByMin(){_PrintTreeByMin(root);}
 29 private:
 30     int BalanceFactor(AVLTNode* node);
 31     AVLTNode* Rotate(AVLTNode* node);
 32     void _PrintTreeByMin(AVLTNode* node);
 33     AVLTNode* InsertNode(Datatype x, AVLTNode* node);
 34     AVLTNode* DeleteNode(Datatype x, AVLTNode* node);
 35     int Height(AVLTNode* node);
 36     AVLTNode* RightRotate(AVLTNode* root);
 37     AVLTNode* LeftRotate(AVLTNode* root);
 38     AVLTNode* RightLeftRotate(AVLTNode* root);
 39     AVLTNode* LeftRightRotate(AVLTNode* root);
 40 public:
 41     AVLTNode* root;
 42 };
 43 
 44 int AVLTree::Height(AVLTNode* node)
 45 {
 46     if (!node)
 47     {
 48         return 0;
 49     }
 50     return node->height;
 51 }
 52 AVLTNode* AVLTree::RightRotate(AVLTNode* root)
 53 {
 54     AVLTNode *temp;
 55     temp = root->pLeft;
 56     root->pLeft = temp->pRight;
 57     temp->pRight = root;
 58 
 59     root->height = MAX(Height(root->pLeft), Height(root->pRight)) + 1;
 60     temp->height = MAX(Height(temp->pLeft), Height(temp->pRight)) + 1;
 61 
 62     return temp;
 63 }
 64 AVLTNode* AVLTree::LeftRotate(AVLTNode* root)
 65 {
 66     AVLTNode *temp;
 67     temp = root->pRight;
 68     root->pRight = temp->pLeft;
 69     temp->pLeft = root;
 70 
 71     root->height = MAX(Height(root->pLeft), Height(root->pRight)) + 1;
 72     temp->height = MAX(Height(temp->pLeft), Height(temp->pRight)) + 1;
 73 
 74     return temp;
 75 }
 76 AVLTNode* AVLTree::RightLeftRotate(AVLTNode* root)
 77 {
 78     root->pRight = RightRotate(root->pRight);
 79 
 80     return LeftRotate(root);
 81 }
 82 AVLTNode* AVLTree::LeftRightRotate(AVLTNode* root)
 83 {
 84     root->pLeft = LeftRotate(root->pLeft);
 85     return RightRotate(root);
 86 }
 87 
 88 AVLTNode* AVLTree::InsertNode(Datatype x,AVLTNode* node)
 89 {
 90     if (node==NULL)
 91     {
 92         node = new AVLTNode;
 93         ASSERT(node);
 94         node->data = x;
 95         node->pLeft = NULL;
 96         node->pRight = NULL;
 97         node->height = 1;
 98         return node;
 99     }
100     else if (x < node->data)
101     {
102         node->pLeft = InsertNode(x, node->pLeft);
103         if (Height(node->pLeft)-Height(node->pRight) == 2)
104         {
105             if (x < node->pLeft->data)
106             {
107                 node = RightRotate(node);
108             }
109             else
110             {
111                 node = LeftRightRotate(node);
112             }
113         }        
114     }
115     else
116     {
117         node->pRight = InsertNode(x, node->pRight);
118         if (Height(node->pRight)-Height(node->pLeft) == 2)
119         {
120             if (x > node->pRight->data)
121             {
122                 node = LeftRotate(node);
123             }
124             else
125             {
126                 node = RightLeftRotate(node);
127             }
128         }
129     }
130     node->height = MAX(Height(node->pLeft), Height(node->pRight)) + 1;
131     return node;
132 }
133 
134 void AVLTree::_PrintTreeByMin(AVLTNode* node)
135 { 
136     if (!node)
137     {
138         return;
139     }
140     _PrintTreeByMin(node->pLeft);
141     cout<<node->data<<"("<<node->height<<")"<<" ";
142     _PrintTreeByMin(node->pRight);
143 }
144 //对于二叉树的删除操作,先递归的搜索要删除的节点A,用该节点的右儿子
145 //的最左儿子B代替该节点,以A的右儿子和B当前的数值作为线索继续遍历,
146 //只到找到B,删除B。然后递归的对B的祖先节点进行平衡调整,具体调整操作
147 //和二叉树的插入操作的平衡调整相同。
148 AVLTNode* AVLTree::DeleteNode(Datatype x, AVLTNode* node)
149 {
150     AVLTNode *temp=NULL;
151     if (node == NULL)
152     {
153         return NULL;
154     }
155     if (node->data == x)
156     {
157         if (node->pRight==NULL)
158         {
159             //无有孩子
160             temp = node;
161             node = node->pLeft;
162             free(temp);
163             temp = NULL;
164         }
165         else
166         {
167             //有则用其右孩子的最左孩子替换该节点
168             temp = node->pRight;
169             while(temp->pLeft)
170             {
171                 temp = temp->pLeft;
172             }
173             node->data = temp->data;
174             node->pRight = DeleteNode(node->data, node->pRight);//删除的值,和传入的根结点发生了变化
175             node->height = MAX(Height(node->pLeft), Height(node->pRight))+1;
176         }
177         return node; //
178     }else if (node->data < x)
179     {
180         node->pRight = DeleteNode(x, node->pRight);
181         if (node->pRight)
182         {
183             node->pRight = Rotate(node->pRight);
184         }
185         
186     }
187     else
188     {
189         node->pLeft = DeleteNode(x, node->pLeft);
190         if (node->pLeft)
191         {
192             node->pLeft = Rotate(node->pLeft);
193         }
194     }
195     node->height = MAX(Height(node->pLeft), Height(node->pRight))+1;
196     node = Rotate(node);
197     return node;
198 }
199 
200 int AVLTree::BalanceFactor(AVLTNode* node)
201 {
202     if (!node)
203     {
204         return 0;
205     }
206     return Height(node->pLeft)-Height(node->pRight);
207 }
208 
209 AVLTNode* AVLTree::Rotate(AVLTNode* node)
210 {
211     if(Height(node->pLeft) - Height(node->pRight) == 2)
212     {
213         if(Height(node->pLeft->pLeft) >= Height(node->pLeft->pRight))
214         {
215             node = RightRotate(node);
216         }
217         else{
218             node = LeftRightRotate(node);
219         }
220     }
221     if(Height(node->pRight) - Height(node->pLeft) == 2)
222     {
223         if(Height(node->pRight->pRight) >= Height(node->pRight->pLeft))
224         {
225             node = LeftRotate(node);
226         }
227         else{
228             node = RightLeftRotate(node);
229         }
230     }
231 
232     return node;
233 }
234 
235 
236 int main()
237 {
238     AVLTree avltree;
239 
240     int num[] = {16,3,7,11,9,26,18,14,15};
241     for (int i=0; i<SIZEOFARRY(num); i++)
242     {
243         avltree.InsertNode(num[i]);
244     }
245 
246     avltree.PrintTreeByMin();
247     cout<<endl;
248     avltree.DeleteNode(14);
249     avltree.PrintTreeByMin();
250     cout<<endl;
251     avltree.DeleteNode(26);
252     avltree.PrintTreeByMin();
253 
254     cout<<endl;
255     return 0;
256 }

相关文章: