二叉查找树的C++实现

  1 #include <iostream>
  2 #include <algorithm>
  3 #include <stack>
  4 using namespace std;
  5 ////////
  6 template <typename T>
  7 class BinarySearchTree{
  8 /////////
  9 private:
 10     struct BinaryNode{
 11         T element;
 12         BinaryNode* left;
 13         BinaryNode* right;
 14         BinaryNode(T ele, BinaryNode* lt, BinaryNode* rt): element(ele),
 15             left(lt), right(rt){}
 16     };
 17     BinaryNode* root;
 18     BinaryNode* clone(BinaryNode* t)const{
 19         if(t == NULL)
 20             return NULL;
 21         return new BinaryNode(t->element, clone(t->left), clone(t->right));
 22     }
 23     void makeEmpty(BinaryNode* &t){//mind here
 24         if(t != NULL){
 25             makeEmpty(t->left);
 26             makeEmpty(t->right);
 27             delete t;//mind here...
 28         }
 29         t = NULL;
 30     }
 31 ////////
 32 public:
 33     BinarySearchTree(){
 34         root = new BinaryNode(0, NULL, NULL);
 35     }
 36     BinarySearchTree(const BinarySearchTree& rhs): root(clone(rhs.root)){}
 37     const BinarySearchTree& operator=(const BinarySearchTree& rhs){
 38         if(this != &rhs){
 39             makeEmpty(this->root);
 40             root = clone(rhs.root);
 41         }
 42         return *this;
 43     }
 44     ~BinarySearchTree(){
 45         if(root != NULL)
 46             makeEmpty(root);
 47     }
 48 /// concrete algorithms
 49     BinaryNode* findMax(const BinaryNode* t){
 50         if(t == NULL)
 51             return NULL;
 52         if(t->right == NULL)
 53             return t;
 54         return findMax(t->right);
 55     }
 56 ///
 57     BinaryNode* findMin(const BinaryNode* t){
 58         if(t == NULL)
 59             return NULL;
 60         if(t->left == NULL)
 61             return t;
 62         return findMin(t->left);
 63     }
 64 
 65 
 66     bool isBinarySearchTree(const BinaryNode* root){
 67         if(root != NULL){
 68             if(root->right == NULL && root->left == NULL)
 69                 return true;
 70             if(root->left != NULL && root->right == NULL 
 71                 && root->left->element < root->element)
 72                 return isBinarySearchTree(root->left);
 73             if(root->left == NULL && root->right != NULL
 74                 && root->element < root->right->element)
 75                 return isBinarySearchTree(root->right);
 76             if(root->left && root->right 
 77                 && root->element < root->right->element
 78                 && root->left->element < root->element)
 79                 return isBinarySearchTree(root->left) && isBinarySearchTree(root->right);
 80             return false;
 81         }
 82         return true;
 83     }
 84     void numofNode(const BinaryNode* root, int& num){
 85         if(root != NULL){
 86             if(root->left == NULL && root->right == NULL)
 87                 ++num;
 88             if(root->left != NULL && root->right == NULL){
 89                 ++num;
 90                 numofNode(root->left, num);
 91             }
 92             if(root->left == NULL && root->right != NULL){
 93                 ++num;
 94                 numofNode(root->right, num);
 95             }
 96             if(root->left != NULL && root->right !=NULL){
 97                 ++num;
 98                 numofNode(root->left, num);
 99                 numofNode(root->right, num);
100             }
101         }
102     }
103 
104     void numofLeafNode(const BinaryNode* root, int& num){
105         if(root != NULL){
106             if(root->left == NULL && root->right == NULL){
107                 ++num;
108             }
109             if(root->left != NULL && root->right == NULL){
110                 numofLeafNode(root->left, num);
111             }
112             if(root->left == NULL && root->right != NULL){
113                 numofLeafNode(root->right, num);
114             }
115             if(root->left != NULL && root->right !=NULL){
116                 numofLeafNode(root->left, num);
117                 numofLeafNode(root->right, num);
118             }           
119         }
120     }
121 
122     void numoffullNode(const BinaryNode* root, int& num){
123         if(root != NULL){
124             if(root->left == NULL && root->right == NULL){
125                 ++num;
126             }
127             if(root->left != NULL && root->right == NULL){
128                 numoffullNode(root->left, num);
129             }
130             if(root->left == NULL && root->right != NULL){
131                 numoffullNode(root->right, num);
132             }
133             if(root->left != NULL && root->right !=NULL){
134                 numofLeafNode(root->left, num);
135                 numofLeafNode(root->right, num);
136             }           
137         }
138     }
139 
140 
141 ////
142     bool contains(const T& x, const BinaryNode* t){
143         if(t == NULL)
144             return false;
145         if(x < t->element)
146             return contains(x, t->left);
147         else if(x > t->right)
148             return contains(x, t->right);
149         else
150             return true;
151     }
152 ///
153     void insert_s(const T& x, BinaryNode* & t){
154         if(t == NULL)
155             t = new BinaryNode(x, NULL, NULL);
156         if(x < t->element)
157             insert_s(x, t->left);
158         else if(x > t->element)
159             insert_s(x, t->right);
160         else
161             ;
162     }
163     void insert(const T& x){
164         insert_s(x, root);
165     }
166 ///
167     void remove_s(const T& x, BinaryNode* & t){
168         if(t == NULL)
169             return;
170         if(x < t->element)
171             remove_s(x, t->left);
172         else if(x, t->element)
173             remove_s(x, t->right);
174         else if(t->right != NULL && t->left != NULL){
175             t->element = findMin(t->right)->element;
176             remove_s(t->element, t->right);
177         }
178         else{
179             BinaryNode* old = t;
180             t = (t->left != NULL)? t->left: t->right;
181             delete old;
182         }
183     }
184     void remove(const T& x){
185         remove_s(x, root);
186     }
187 ///
188     void printTree_s(const BinaryNode* t){
189         if(t != NULL){
190             printTree_s(t->left);
191             printTree_s(t->right);  
192             cout << t->element << endl;
193         }
194     }
195     void printTree(){
196         printTree_s(root);
197     }
198 
199     //前序遍历
200     void PreOrderTraverseRec(const BinaryNode* root){
201         if(root != NULL){
202             cout << root->element << endl;
203             PreOrderTraverseRec(root->left);
204             PreOrderTraverseRec(root->right);
205         }
206     }
207     void PreOrderTraverseNonRec_1(const BinaryNode* root){
208         if(root == NULL){
209             cout << "enmpty tree...\n";
210         }
211         else{
212             stack<BinaryNode*> st;
213             BinaryNode* curr = root;
214             st.push(curr);
215             while(!st.empty()){
216                 curr = st.top();
217                 cout << curr->element << endl;
218                 st.pop();
219                 if(curr->right != NULL)
220                     st.push(curr->right);
221                 if(curr->left != NULL)
222                     st.push(curr->left);
223             }
224         }
225     }
226 
227     void PreOrderTraverseNonRec_2(const BinaryNode* root){
228         if(root == NULL)
229             cout << "empty tree...\n";
230         else{
231             stack<BinaryNode*> st;
232             BinaryNode* curr = root;
233             while(!st.empty() || curr != NULL){
234                 while(curr != NULL){
235                     st.push(curr);
236                     cout << curr->element << endl;
237                     curr = curr->left;
238                 }
239                 if(!st.empty()){
240                     curr = st.top();
241                     st.pop();
242                     curr = curr->right;
243                 }
244             }
245         }
246     }
247     void PreOrderTraverseMorris(const BinaryNode* root){
248         BinaryNode* curr = root;
249         BinaryNode* pre = NULL;
250         while(curr != NULL){
251             if(curr->left == NULL){
252                 cout << curr->element << endl;
253                 curr = curr->right;
254             }
255             else{
256                 pre = curr->left;
257                 while(pre->right != NULL && pre->right != curr)
258                     pre = pre->right;
259                 if(pre->right == NULL){
260                     cout << curr->element << endl;
261                     pre->right = curr;
262                     curr = curr->left;
263                 }
264                 else{
265                     pre->right = NULL;
266                     curr = curr->right;
267                 }
268             }
269         }
270     }
271 
272 
273     //中序遍历
274     void InOrderTraverselRec(const BinaryNode* root){
275         if(root != NULL){
276             InOrderTraverselRec(root->left);
277             cout << root->element << endl;
278             InOrderTraverselRec(root->right);
279         }
280     }
281 
282     void InOrderTraverselNonRec(const BinaryNode* root){
283         if(root == NULL)
284             cout << "empty tree...\n";
285         else{
286             stack<BinaryNode*> st;
287             BinaryNode* curr = root;
288             while(!st.empty() || curr != NULL){
289                 while(curr != NULL){
290                     st.push(curr);
291                     curr = curr->left;
292                 }
293                 if(!st.empty()){
294                     curr = st.top();
295                     st.pop();
296                     cout << curr->element << endl;
297                     curr = curr->right;
298                 }
299             }
300         }
301     }
302     void InOrderTraverselMorris(const BinaryNode* root){
303         BinaryNode* curr = root;
304         BinaryNode* pre = NULL;
305         while(curr != NULL){
306             if(curr->left == NULL){
307                 cout << curr->element << endl;
308                 curr = curr->right;
309             }
310             else{
311                 pre = curr->left;
312                 while(pre->right != NULL && pre->right != curr)
313                     pre = pre->right;
314                 if(pre->right == NULL){
315                     pre->right = curr;
316                     curr = curr->left;
317                 }
318                 else{
319                     pre->right = NULL;
320                     cout << curr->element << endl;
321                     curr = curr->right;
322                 }
323             }
324         }
325     }
326     //后续遍历
327     void PostOrderTraverseRec(const BinaryNode* root){
328         if(root != NULL){
329             PostOrderTraverseRec(root->left);
330             PostOrderTraverseRec(root->right);
331             cout << root->element;
332         }
333     }
334 
335     void PostOrderTraverseNonRec_1(const BinaryNode* root){
336         if(root == NULL)
337             cout << "empty tree...\n";
338         else{
339             stack<BinaryNode*> st;
340             BinaryNode* curr = root;
341             BinaryNode* pre = NULL;
342             while(!st.empty() || curr != NULL){
343                 while(curr != NULL){
344                     st.push(curr);
345                     curr = curr->left;
346                 }
347                 if(!st.empty()){
348                     curr = st.top();
349                     if(curr->right == NULL || pre == curr->right){
350                         cout << curr->element << endl;
351                         st.pop();
352                         pre = curr;
353                         curr == NULL;
354                     }
355                     else
356                         curr = curr->right;
357                 }
358             }
359         }
360     }
361 
362     void PostOrderTraverseNonRec_2(const BinaryNode* root){
363         if(root == NULL)
364             cout << "empty tree...\n";
365         else{
366             stack<BinaryNode*> st;
367             BinaryNode* curr = root;
368             BinaryNode* pre = NULL;
369             st.push(curr);
370             while(!st.empty() || curr != NULL){
371                 curr = st.top();
372                 if((curr->left == NULL && curr->right == NULL) || 
373                   ((curr->right == NULL && pre == curr->left) || 
374                     pre == curr->right)){
375                     st.pop();
376                     cout << curr->element;
377                     pre = curr;
378                 }
379                 else{
380                     if(curr->right != NULL)
381                         st.push(curr->right);
382                     if(curr->left != NULL)
383                         st.push(curr->left);
384                 }
385             }
386         }       
387     }
388 
389     void PostOrderTraverseNonRec_3(const BinaryNode* root){
390         stack<BinaryNode*> st;
391         BinaryNode* curr = root;
392         st.push(curr);
393         st.push(curr);
394         while(!st.empty()){
395             curr = st.top();
396             st.pop();
397             if(!st.empty() && curr == st.top()){
398                 if(curr->right){
399                     st.push(curr->right); st.push(curr->right);
400                 }
401                 if(curr->left){
402                     st.push(curr->left); st.push(curr->left);
403                 }
404             }
405             else
406                 cout << curr->element << endl;
407         }
408     }
409 };
410 
411 int main(){
412     BinarySearchTree<int> lt;
413     lt.insert(10);
414     lt.insert(100);
415     lt.insert(-10);
416     lt.printTree();
417     return 0;
418 }
posted @ 2018-08-16 19:31 技术人员kelvin 阅读(519) 评论(0) 收藏举报
刷新页面返回顶部
技术人员kelvin

二叉查找树的C++实现

公告
