zoukankan html css js c++ java

第六十八课二叉树的比较与相加

克隆操作也是递归实现的。

添加克隆函数：

  1 #ifndef BTREE_H
  2 #define BTREE_H
  3 
  4 #include "Tree.h"
  5 #include "BTreeNode.h"
  6 #include "Exception.h"
  7 #include "LinkQueue.h"
  8 #include "DynamicArray.h"
  9 
 10 
 11 namespace DTLib
 12 {
 13 
 14 enum BTTraversal
 15 {
 16     PreOrder,
 17     InOrder,
 18     PostOrder
 19 };
 20 
 21 template < typename T >
 22 class BTree : public Tree<T>
 23 {
 24 protected:
 25     LinkQueue<BTreeNode<T>*> m_queue;
 26     //定义递归功能函数
 27     virtual BTreeNode<T>* find(BTreeNode<T>* node, const T& value) const
 28     {
 29         BTreeNode<T>* ret = NULL;
 30 
 31         if( node != NULL )
 32         {
 33             if( node->value == value )
 34             {
 35                 ret = node;
 36             }
 37             else
 38             {
 39                 if( ret == NULL )
 40                 {
 41                     ret = find(node->left, value);
 42                 }
 43 
 44                 if( ret == NULL )
 45                 {
 46                     ret = find(node->right, value);
 47                 }
 48             }
 49         }
 50 
 51         return ret;
 52     }
 53 
 54     virtual BTreeNode<T>* find(BTreeNode<T>* node, BTreeNode<T>* obj) const
 55     {
 56         BTreeNode<T>* ret = NULL;
 57 
 58         if( node == obj )
 59         {
 60             ret = node;
 61         }
 62         else
 63         {
 64             if( node != NULL )
 65             {
 66                 if( ret == NULL )
 67                 {
 68                     ret = find(node->left, obj);
 69                 }
 70 
 71                 if( ret == NULL )
 72                 {
 73                     ret = find(node->right, obj);
 74                 }
 75             }
 76         }
 77 
 78         return ret;
 79     }
 80 
 81     virtual bool insert(BTreeNode<T>* n, BTreeNode<T>* np, BTNodePos pos)
 82     {
 83         bool ret = true;
 84 
 85         if( pos == ANY )
 86         {
 87             if( np->left == NULL )
 88             {
 89                 np->left = n;
 90             }
 91             else if( np->right == NULL )
 92             {
 93                 np->right = n;
 94             }
 95             else
 96             {
 97                 ret = false;
 98             }
 99         }
100         else if( pos == LEFT )
101         {
102             if( np->left == NULL )
103             {
104                 np->left = n;
105             }
106             else
107             {
108                 ret = false;
109             }
110         }
111         else if( pos == RIGHT )
112         {
113             if( np->right == NULL )
114             {
115                 np->right = n;
116             }
117             else
118             {
119                 ret = false;
120             }
121         }
122         else
123         {
124             ret = false;
125         }
126 
127         return ret;
128     }
129 
130     virtual void remove(BTreeNode<T>* node, BTree<T>*& ret)
131     {
132         ret = new BTree<T>();
133 
134         if( ret == NULL )
135         {
136             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create btree...");
137         }
138         else
139         {
140             if( root() == node )
141             {
142                 this->m_root = NULL;
143             }
144             else
145             {
146                 BTreeNode<T>* parent = dynamic_cast<BTreeNode<T>*>(node->parent);
147 
148                 if( parent->left == node )
149                 {
150                     parent->left = NULL;
151                 }
152                 else if( parent->right == node )
153                 {
154                     parent->right = NULL;
155                 }
156 
157                 node->parent = NULL;
158             }
159 
160             ret->m_root = node;  //作为子树返回
161         }
162     }
163 
164     virtual void free(BTreeNode<T>* node)
165     {
166         if( node != NULL )
167         {
168             free(node->left);
169             free(node->right);
170 
171             if( node->flag() )
172             {
173                 delete node;
174             }
175         }
176     }
177     #if 0
178     int count(BTreeNode<T>* node) const
179     {
180         int ret = 0;
181 
182         if( node != NULL )
183         {
184             ret = count(node->left) + count(node->right) + 1;
185         }
186 
187         return ret;
188     }
189     #endif
190 
191     int count(BTreeNode<T>* node) const
192     {
193         return (node != NULL) ? (count(node->left) + count(node->right) + 1) : 0;
194     }
195 
196     int height(BTreeNode<T>* node) const
197     {
198         int ret = 0;
199 
200         if( node != NULL )
201         {
202             int lh = height(node->left);
203             int rh = height(node->right);
204 
205             ret = ((lh > rh) ? lh : rh) + 1;;
206         }
207 
208         return ret;
209     }
210 
211 #if 0
212     int degree(BTreeNode<T>* node) const
213     {
214         int ret = 0;
215 
216         if( node != NULL )
217         {
218             int dl = degree(node->left);
219             int dr = degree(node->right);
220 
221             ret = (!!node->left + !!node->right);
222 
223             if( ret < dl )
224             {
225                 ret = dl;
226             }
227 
228             if( ret < dr )
229             {
230                 ret = dr;
231             }
232         }
233 
234         return ret;
235     }
236 #endif
237 //二叉树的最大度数为2，上面的实现效率太低
238     int degree(BTreeNode<T>* node) const
239     {
240         int ret = 0;
241 
242         if( node != NULL )
243         {
244             BTreeNode<T>* child[] = {node->left, node->right};
245 
246             ret = (!!node->left + !!node->right);
247 
248             for( int i = 0; (i < 2) && (ret < 2); i++)
249             {
250                 int d = degree(child[i]);
251 
252                 if( ret < d )
253                 {
254                     ret = d;
255                 }
256             }
257         }
258 
259         return ret;
260     }
261 
262     void preOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue)
263     {
264         if( node != NULL )
265         {
266             queue.add(node);
267             preOrderTraversal(node->left, queue);
268             preOrderTraversal(node->right, queue);
269         }
270     }
271 
272     void inOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue)
273     {
274         if( node != NULL )
275         {
276             inOrderTraversal(node->left, queue);
277             queue.add(node);
278             inOrderTraversal(node->right, queue);
279         }
280     }
281 
282     void postOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue)
283     {
284         if( node != NULL )
285         {
286             postOrderTraversal(node->left, queue);
287             postOrderTraversal(node->right, queue);
288             queue.add(node);
289         }
290     }
291 
292     BTreeNode<T>* clone(BTreeNode<T>* node) const
293     {
294         BTreeNode<T>* ret = NULL;
295 
296         if( node != NULL )
297         {
298             ret = BTreeNode<T>::NewNode();
299 
300             if( ret != NULL )
301             {
302                 ret->value = node->value;
303 
304                 ret->left = clone(node->left);
305                 ret->right = clone(node->right);
306 
307                 if( ret->left != NULL )
308                 {
309                     ret->left->parent = ret;
310                 }
311 
312                 if( ret->right != NULL )
313                 {
314                     ret->right->parent = ret;
315                 }
316             }
317             else
318             {
319                 THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create node...");
320             }
321         }
322 
323         return ret;
324     }
325 public:
326     bool insert(TreeNode<T>* node)
327     {
328         return insert(node, ANY);
329     }
330 
331     virtual bool insert(TreeNode<T>* node, BTNodePos pos)
332     {
333         bool ret = true;
334 
335         if( node != NULL )
336         {
337             if( this->m_root == NULL )  //空树
338             {
339                 node->parent = NULL;
340                 this->m_root = node;
341             }
342             else
343             {
344                 BTreeNode<T>* np = find(node->parent);
345 
346                 if( np != NULL )
347                 {
348                     ret = insert(dynamic_cast<BTreeNode<T>*>(node), np, pos);
349                 }
350                 else
351                 {
352                     THROW_EXCEPTION(InvalidParameterException, "invalid parent tree node...");
353                 }
354             }
355         }
356         else
357         {
358             THROW_EXCEPTION(InvalidParameterException, "parameter node can not be null...");
359         }
360 
361         return ret;
362     }
363 
364     bool insert(const T& value, TreeNode<T>* parent)
365     {
366         return insert(value, parent, ANY);
367     }
368 
369     virtual bool insert(const T& value, TreeNode<T>* parent, BTNodePos pos)
370     {
371         bool ret = true;
372         BTreeNode<T>* node = BTreeNode<T>::NewNode();
373 
374         if( node == NULL )
375         {
376             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create node...");
377         }
378         else
379         {
380             node->value = value;
381             node->parent = parent;
382 
383             ret = insert(node, pos);
384 
385             if( !ret )
386             {
387                 delete node;
388             }
389         }
390 
391         return ret;
392     }
393 
394     SharedPointer< Tree<T> > remove(TreeNode<T>* node) //删除的节点的子节点我们还需要处理，因此要返回删除节点的指针，//这样有机会对里面的元素做进一步操作
395     {
396         BTree<T>* ret = NULL;
397 
398         node = find(node);
399 
400         if( node == NULL )
401         {
402             THROW_EXCEPTION(InvalidParameterException, "parameter is invalid...");
403         }
404         else
405         {
406             remove(dynamic_cast<BTreeNode<T>*>(node), ret);
407 
408             m_queue.clear();
409         }
410 
411         return ret;
412     }
413 
414     SharedPointer< Tree<T> > remove(const T& value)
415     {
416         BTree<T>* ret = NULL;
417 
418         BTreeNode<T>* node = find(value);
419 
420         if( node == NULL )
421         {
422             THROW_EXCEPTION(InvalidParameterException, "can not find node via value...");
423         }
424         else
425         {
426             remove(node, ret);
427 
428             m_queue.clear();
429         }
430 
431         return ret;
432     }
433 
434     BTreeNode<T>* find(const T& value) const
435     {
436         return find(root(), value);
437     }
438 
439     BTreeNode<T>* find(TreeNode<T>* node) const
440     {
441         return find(root(), dynamic_cast<BTreeNode<T>*>(node));
442     }
443 
444     BTreeNode<T>* root() const
445     {
446         return dynamic_cast<BTreeNode<T>*>(this->m_root);
447     }
448 
449     int degree() const
450     {
451         return degree(root());
452     }
453 
454     int count() const
455     {
456         return count(root());
457     }
458 
459     int height() const
460     {
461         return height(root());
462     }
463 
464     void clear()
465     {
466         free(root());
467 
468         m_queue.clear();
469 
470         this->m_root = NULL;
471     }
472 
473     bool begin()
474     {
475         bool ret = ( root() != NULL );
476 
477         if( ret )
478         {
479             m_queue.clear();
480             m_queue.add(root());
481         }
482 
483         return ret;
484     }
485 
486     bool end()
487     {
488         return (m_queue.length() == 0);
489     }
490 
491     bool next()
492     {
493         bool ret = (m_queue.length() > 0);
494 
495         if( ret )
496         {
497             BTreeNode<T>* node = m_queue.front();
498 
499             m_queue.remove();  //将对头元素出队，相当于移动游标
500 
501             if( node->left != NULL )
502             {
503                 m_queue.add(node->left);
504             }
505 
506             if( node->right )
507             {
508                 m_queue.add(node->right);
509             }
510         }
511 
512         return ret;
513     }
514 
515     T current()
516     {
517         if( !end() )  //遍历的过程当中调用current函数才有意义
518         {
519             return m_queue.front()->value;
520         }
521         else
522         {
523             THROW_EXCEPTION(InvalidOperationException, "No value at current position...");
524         }
525     }
526 
527     SharedPointer< Array<T> > traversal(BTTraversal order)
528     {
529         DynamicArray<T>* ret = NULL;
530         LinkQueue<BTreeNode<T>*> queue;
531 
532         switch( order ){
533         case PreOrder:
534             preOrderTraversal(root(), queue);
535             break;
536         case InOrder:
537             inOrderTraversal(root(), queue);
538             break;
539         case PostOrder:
540             postOrderTraversal(root(), queue);
541             break;
542         default:
543             THROW_EXCEPTION(InvalidParameterException, "parameter is invalid...");
544             break;
545         }
546 
547         ret = new DynamicArray<T>(queue.length());
548         //遍历完将结果保存到动态数组中去
549         if( ret != NULL )
550         {
551             for(int i = 0; i < ret->length(); i++, queue.remove())
552             {
553                 ret->set(i, queue.front()->value);
554             }
555         }
556         else
557         {
558             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create array...");
559         }
560 
561         return ret;
562     }
563 
564     SharedPointer< BTree<T> > clone() const
565     {
566         BTree<T>* ret = new BTree<T>();
567 
568         if( ret != NULL )
569         {
570             ret->m_root = clone(root());
571         }
572         else
573         {
574             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new btree...");
575         }
576 
577         return ret;
578     }
579 
580     ~BTree()
581     {
582         clear();
583     }
584 };
585 
586 }
587 
588 #endif // BTREE_H

测试程序如下：

 1 #include <iostream>
 2 #include "GTree.h"
 3 #include "GTreeNode.h"
 4 #include "BTree.h"
 5 #include "BTreeNode.h"
 6 
 7 
 8 using namespace std;
 9 using namespace DTLib;
10 
11 
12 int main()
13 {
14     BTree<int> bt;
15     BTreeNode<int>* n = NULL;
16 
17     bt.insert(1, NULL);
18 
19     n = bt.find(1);
20     bt.insert(2, n);
21     bt.insert(3, n);
22 
23     n = bt.find(2);
24     bt.insert(4, n);
25     bt.insert(5, n);
26 
27     n = bt.find(4);
28     bt.insert(8, n);
29     bt.insert(9, n);
30 
31     n = bt.find(5);
32     bt.insert(10, n);
33 
34     n = bt.find(3);
35     bt.insert(6, n);
36     bt.insert(7, n);
37 
38 
39     cout << bt.count() << endl;
40     cout << bt.height() << endl;
41     cout << bt.degree() << endl;
42 
43     SharedPointer< BTree<int> > btClone = bt.clone();
44 
45     int a[] = {8, 9, 10, 7};
46 
47     cout << "Clone: " << endl;
48     for(int i = 0; i < 5; i++)
49     {
50         TreeNode<int>* node = btClone->find(a[i]);
51 
52         while( node )
53         {
54             cout << node->value << " ";
55             node = node->parent;
56         }
57 
58         cout << endl;
59     }
60 
61     cout << "Old tree: " << endl;
62     for(int i = 0; i < 5; i++)
63     {
64         TreeNode<int>* node = bt.find(a[i]);
65 
66         while( node )
67         {
68             cout << node->value << " ";
69             node = node->parent;
70         }
71 
72         cout << endl;
73     }
74 
75 
76     return 0;
77 }

结果如下：

重载相等比较操作符。

添加比较程序：

  1 #ifndef BTREE_H
  2 #define BTREE_H
  3 
  4 #include "Tree.h"
  5 #include "BTreeNode.h"
  6 #include "Exception.h"
  7 #include "LinkQueue.h"
  8 #include "DynamicArray.h"
  9 
 10 
 11 namespace DTLib
 12 {
 13 
 14 enum BTTraversal
 15 {
 16     PreOrder,
 17     InOrder,
 18     PostOrder
 19 };
 20 
 21 template < typename T >
 22 class BTree : public Tree<T>
 23 {
 24 protected:
 25     LinkQueue<BTreeNode<T>*> m_queue;
 26     //定义递归功能函数
 27     virtual BTreeNode<T>* find(BTreeNode<T>* node, const T& value) const
 28     {
 29         BTreeNode<T>* ret = NULL;
 30 
 31         if( node != NULL )
 32         {
 33             if( node->value == value )
 34             {
 35                 ret = node;
 36             }
 37             else
 38             {
 39                 if( ret == NULL )
 40                 {
 41                     ret = find(node->left, value);
 42                 }
 43 
 44                 if( ret == NULL )
 45                 {
 46                     ret = find(node->right, value);
 47                 }
 48             }
 49         }
 50 
 51         return ret;
 52     }
 53 
 54     virtual BTreeNode<T>* find(BTreeNode<T>* node, BTreeNode<T>* obj) const
 55     {
 56         BTreeNode<T>* ret = NULL;
 57 
 58         if( node == obj )
 59         {
 60             ret = node;
 61         }
 62         else
 63         {
 64             if( node != NULL )
 65             {
 66                 if( ret == NULL )
 67                 {
 68                     ret = find(node->left, obj);
 69                 }
 70 
 71                 if( ret == NULL )
 72                 {
 73                     ret = find(node->right, obj);
 74                 }
 75             }
 76         }
 77 
 78         return ret;
 79     }
 80 
 81     virtual bool insert(BTreeNode<T>* n, BTreeNode<T>* np, BTNodePos pos)
 82     {
 83         bool ret = true;
 84 
 85         if( pos == ANY )
 86         {
 87             if( np->left == NULL )
 88             {
 89                 np->left = n;
 90             }
 91             else if( np->right == NULL )
 92             {
 93                 np->right = n;
 94             }
 95             else
 96             {
 97                 ret = false;
 98             }
 99         }
100         else if( pos == LEFT )
101         {
102             if( np->left == NULL )
103             {
104                 np->left = n;
105             }
106             else
107             {
108                 ret = false;
109             }
110         }
111         else if( pos == RIGHT )
112         {
113             if( np->right == NULL )
114             {
115                 np->right = n;
116             }
117             else
118             {
119                 ret = false;
120             }
121         }
122         else
123         {
124             ret = false;
125         }
126 
127         return ret;
128     }
129 
130     virtual void remove(BTreeNode<T>* node, BTree<T>*& ret)
131     {
132         ret = new BTree<T>();
133 
134         if( ret == NULL )
135         {
136             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create btree...");
137         }
138         else
139         {
140             if( root() == node )
141             {
142                 this->m_root = NULL;
143             }
144             else
145             {
146                 BTreeNode<T>* parent = dynamic_cast<BTreeNode<T>*>(node->parent);
147 
148                 if( parent->left == node )
149                 {
150                     parent->left = NULL;
151                 }
152                 else if( parent->right == node )
153                 {
154                     parent->right = NULL;
155                 }
156 
157                 node->parent = NULL;
158             }
159 
160             ret->m_root = node;  //作为子树返回
161         }
162     }
163 
164     virtual void free(BTreeNode<T>* node)
165     {
166         if( node != NULL )
167         {
168             free(node->left);
169             free(node->right);
170 
171             if( node->flag() )
172             {
173                 delete node;
174             }
175         }
176     }
177     #if 0
178     int count(BTreeNode<T>* node) const
179     {
180         int ret = 0;
181 
182         if( node != NULL )
183         {
184             ret = count(node->left) + count(node->right) + 1;
185         }
186 
187         return ret;
188     }
189     #endif
190 
191     int count(BTreeNode<T>* node) const
192     {
193         return (node != NULL) ? (count(node->left) + count(node->right) + 1) : 0;
194     }
195 
196     int height(BTreeNode<T>* node) const
197     {
198         int ret = 0;
199 
200         if( node != NULL )
201         {
202             int lh = height(node->left);
203             int rh = height(node->right);
204 
205             ret = ((lh > rh) ? lh : rh) + 1;;
206         }
207 
208         return ret;
209     }
210 
211 #if 0
212     int degree(BTreeNode<T>* node) const
213     {
214         int ret = 0;
215 
216         if( node != NULL )
217         {
218             int dl = degree(node->left);
219             int dr = degree(node->right);
220 
221             ret = (!!node->left + !!node->right);
222 
223             if( ret < dl )
224             {
225                 ret = dl;
226             }
227 
228             if( ret < dr )
229             {
230                 ret = dr;
231             }
232         }
233 
234         return ret;
235     }
236 #endif
237 //二叉树的最大度数为2，上面的实现效率太低
238     int degree(BTreeNode<T>* node) const
239     {
240         int ret = 0;
241 
242         if( node != NULL )
243         {
244             BTreeNode<T>* child[] = {node->left, node->right};
245 
246             ret = (!!node->left + !!node->right);
247 
248             for( int i = 0; (i < 2) && (ret < 2); i++)
249             {
250                 int d = degree(child[i]);
251 
252                 if( ret < d )
253                 {
254                     ret = d;
255                 }
256             }
257         }
258 
259         return ret;
260     }
261 
262     void preOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue)
263     {
264         if( node != NULL )
265         {
266             queue.add(node);
267             preOrderTraversal(node->left, queue);
268             preOrderTraversal(node->right, queue);
269         }
270     }
271 
272     void inOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue)
273     {
274         if( node != NULL )
275         {
276             inOrderTraversal(node->left, queue);
277             queue.add(node);
278             inOrderTraversal(node->right, queue);
279         }
280     }
281 
282     void postOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue)
283     {
284         if( node != NULL )
285         {
286             postOrderTraversal(node->left, queue);
287             postOrderTraversal(node->right, queue);
288             queue.add(node);
289         }
290     }
291 
292     BTreeNode<T>* clone(BTreeNode<T>* node) const
293     {
294         BTreeNode<T>* ret = NULL;
295 
296         if( node != NULL )
297         {
298             ret = BTreeNode<T>::NewNode();
299 
300             if( ret != NULL )
301             {
302                 ret->value = node->value;
303 
304                 ret->left = clone(node->left);
305                 ret->right = clone(node->right);
306 
307                 if( ret->left != NULL )
308                 {
309                     ret->left->parent = ret;
310                 }
311 
312                 if( ret->right != NULL )
313                 {
314                     ret->right->parent = ret;
315                 }
316             }
317             else
318             {
319                 THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create node...");
320             }
321         }
322 
323         return ret;
324     }
325 
326     bool equal(BTreeNode<T>* lh, BTreeNode<T>* rh) const
327     {
328         if( lh == rh )
329         {
330             return true;
331         }
332         else if( (lh != NULL) && (rh != NULL) )
333         {
334             return (lh->value == rh->value) && equal(lh->left, rh->left) && equal(lh->right, rh->right);
335         }
336         else
337         {
338             return false;
339         }
340     }
341 public:
342     bool insert(TreeNode<T>* node)
343     {
344         return insert(node, ANY);
345     }
346 
347     virtual bool insert(TreeNode<T>* node, BTNodePos pos)
348     {
349         bool ret = true;
350 
351         if( node != NULL )
352         {
353             if( this->m_root == NULL )  //空树
354             {
355                 node->parent = NULL;
356                 this->m_root = node;
357             }
358             else
359             {
360                 BTreeNode<T>* np = find(node->parent);
361 
362                 if( np != NULL )
363                 {
364                     ret = insert(dynamic_cast<BTreeNode<T>*>(node), np, pos);
365                 }
366                 else
367                 {
368                     THROW_EXCEPTION(InvalidParameterException, "invalid parent tree node...");
369                 }
370             }
371         }
372         else
373         {
374             THROW_EXCEPTION(InvalidParameterException, "parameter node can not be null...");
375         }
376 
377         return ret;
378     }
379 
380     bool insert(const T& value, TreeNode<T>* parent)
381     {
382         return insert(value, parent, ANY);
383     }
384 
385     virtual bool insert(const T& value, TreeNode<T>* parent, BTNodePos pos)
386     {
387         bool ret = true;
388         BTreeNode<T>* node = BTreeNode<T>::NewNode();
389 
390         if( node == NULL )
391         {
392             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create node...");
393         }
394         else
395         {
396             node->value = value;
397             node->parent = parent;
398 
399             ret = insert(node, pos);
400 
401             if( !ret )
402             {
403                 delete node;
404             }
405         }
406 
407         return ret;
408     }
409 
410     SharedPointer< Tree<T> > remove(TreeNode<T>* node) //删除的节点的子节点我们还需要处理，因此要返回删除节点的指针，//这样有机会对里面的元素做进一步操作
411     {
412         BTree<T>* ret = NULL;
413 
414         node = find(node);
415 
416         if( node == NULL )
417         {
418             THROW_EXCEPTION(InvalidParameterException, "parameter is invalid...");
419         }
420         else
421         {
422             remove(dynamic_cast<BTreeNode<T>*>(node), ret);
423 
424             m_queue.clear();
425         }
426 
427         return ret;
428     }
429 
430     SharedPointer< Tree<T> > remove(const T& value)
431     {
432         BTree<T>* ret = NULL;
433 
434         BTreeNode<T>* node = find(value);
435 
436         if( node == NULL )
437         {
438             THROW_EXCEPTION(InvalidParameterException, "can not find node via value...");
439         }
440         else
441         {
442             remove(node, ret);
443 
444             m_queue.clear();
445         }
446 
447         return ret;
448     }
449 
450     BTreeNode<T>* find(const T& value) const
451     {
452         return find(root(), value);
453     }
454 
455     BTreeNode<T>* find(TreeNode<T>* node) const
456     {
457         return find(root(), dynamic_cast<BTreeNode<T>*>(node));
458     }
459 
460     BTreeNode<T>* root() const
461     {
462         return dynamic_cast<BTreeNode<T>*>(this->m_root);
463     }
464 
465     int degree() const
466     {
467         return degree(root());
468     }
469 
470     int count() const
471     {
472         return count(root());
473     }
474 
475     int height() const
476     {
477         return height(root());
478     }
479 
480     void clear()
481     {
482         free(root());
483 
484         m_queue.clear();
485 
486         this->m_root = NULL;
487     }
488 
489     bool begin()
490     {
491         bool ret = ( root() != NULL );
492 
493         if( ret )
494         {
495             m_queue.clear();
496             m_queue.add(root());
497         }
498 
499         return ret;
500     }
501 
502     bool end()
503     {
504         return (m_queue.length() == 0);
505     }
506 
507     bool next()
508     {
509         bool ret = (m_queue.length() > 0);
510 
511         if( ret )
512         {
513             BTreeNode<T>* node = m_queue.front();
514 
515             m_queue.remove();  //将对头元素出队，相当于移动游标
516 
517             if( node->left != NULL )
518             {
519                 m_queue.add(node->left);
520             }
521 
522             if( node->right )
523             {
524                 m_queue.add(node->right);
525             }
526         }
527 
528         return ret;
529     }
530 
531     T current()
532     {
533         if( !end() )  //遍历的过程当中调用current函数才有意义
534         {
535             return m_queue.front()->value;
536         }
537         else
538         {
539             THROW_EXCEPTION(InvalidOperationException, "No value at current position...");
540         }
541     }
542 
543     SharedPointer< Array<T> > traversal(BTTraversal order)
544     {
545         DynamicArray<T>* ret = NULL;
546         LinkQueue<BTreeNode<T>*> queue;
547 
548         switch( order ){
549         case PreOrder:
550             preOrderTraversal(root(), queue);
551             break;
552         case InOrder:
553             inOrderTraversal(root(), queue);
554             break;
555         case PostOrder:
556             postOrderTraversal(root(), queue);
557             break;
558         default:
559             THROW_EXCEPTION(InvalidParameterException, "parameter is invalid...");
560             break;
561         }
562 
563         ret = new DynamicArray<T>(queue.length());
564         //遍历完将结果保存到动态数组中去
565         if( ret != NULL )
566         {
567             for(int i = 0; i < ret->length(); i++, queue.remove())
568             {
569                 ret->set(i, queue.front()->value);
570             }
571         }
572         else
573         {
574             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create array...");
575         }
576 
577         return ret;
578     }
579 
580     SharedPointer< BTree<T> > clone() const
581     {
582         BTree<T>* ret = new BTree<T>();
583 
584         if( ret != NULL )
585         {
586             ret->m_root = clone(root());
587         }
588         else
589         {
590             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new btree...");
591         }
592 
593         return ret;
594     }
595 
596     bool operator == (const BTree<T>& btree)
597     {
598         return equal(root(), btree.root());
599     }
600 
601     bool operator != (const BTree<T>& btree)
602     {
603         return !(*this == btree);
604     }
605 
606     ~BTree()
607     {
608         clear();
609     }
610 };
611 
612 }
613 
614 #endif // BTREE_H

测试程序如下：

 1 #include <iostream>
 2 #include "GTree.h"
 3 #include "GTreeNode.h"
 4 #include "BTree.h"
 5 #include "BTreeNode.h"
 6 
 7 
 8 using namespace std;
 9 using namespace DTLib;
10 
11 
12 int main()
13 {
14     BTree<int> bt;
15     BTreeNode<int>* n = NULL;
16 
17     bt.insert(1, NULL);
18 
19     n = bt.find(1);
20     bt.insert(2, n);
21     bt.insert(3, n);
22 
23     n = bt.find(2);
24     bt.insert(4, n);
25     bt.insert(5, n);
26 
27     n = bt.find(4);
28     bt.insert(8, n);
29     bt.insert(9, n);
30 
31     n = bt.find(5);
32     bt.insert(10, n);
33 
34     n = bt.find(3);
35     bt.insert(6, n);
36     bt.insert(7, n);
37 
38 
39     cout << bt.count() << endl;
40     cout << bt.height() << endl;
41     cout << bt.degree() << endl;
42 
43     SharedPointer< BTree<int> > btClone = bt.clone();
44 
45     int a[] = {8, 9, 10, 7};
46 
47     cout << "Clone: " << endl;
48     for(int i = 0; i < 5; i++)
49     {
50         TreeNode<int>* node = btClone->find(a[i]);
51 
52         while( node )
53         {
54             cout << node->value << " ";
55             node = node->parent;
56         }
57 
58         cout << endl;
59     }
60 
61     cout << "Old tree: " << endl;
62     for(int i = 0; i < 5; i++)
63     {
64         TreeNode<int>* node = bt.find(a[i]);
65 
66         while( node )
67         {
68             cout << node->value << " ";
69             node = node->parent;
70         }
71 
72         cout << endl;
73     }
74 
75     cout << "bt == *btClone : " << (bt == *btClone) << endl;
76 
77     return 0;
78 }

结果如下：

添加相加操作：

  1 #ifndef BTREE_H
  2 #define BTREE_H
  3 
  4 #include "Tree.h"
  5 #include "BTreeNode.h"
  6 #include "Exception.h"
  7 #include "LinkQueue.h"
  8 #include "DynamicArray.h"
  9 
 10 
 11 namespace DTLib
 12 {
 13 
 14 enum BTTraversal
 15 {
 16     PreOrder,
 17     InOrder,
 18     PostOrder
 19 };
 20 
 21 template < typename T >
 22 class BTree : public Tree<T>
 23 {
 24 protected:
 25     LinkQueue<BTreeNode<T>*> m_queue;
 26     //定义递归功能函数
 27     virtual BTreeNode<T>* find(BTreeNode<T>* node, const T& value) const
 28     {
 29         BTreeNode<T>* ret = NULL;
 30 
 31         if( node != NULL )
 32         {
 33             if( node->value == value )
 34             {
 35                 ret = node;
 36             }
 37             else
 38             {
 39                 if( ret == NULL )
 40                 {
 41                     ret = find(node->left, value);
 42                 }
 43 
 44                 if( ret == NULL )
 45                 {
 46                     ret = find(node->right, value);
 47                 }
 48             }
 49         }
 50 
 51         return ret;
 52     }
 53 
 54     virtual BTreeNode<T>* find(BTreeNode<T>* node, BTreeNode<T>* obj) const
 55     {
 56         BTreeNode<T>* ret = NULL;
 57 
 58         if( node == obj )
 59         {
 60             ret = node;
 61         }
 62         else
 63         {
 64             if( node != NULL )
 65             {
 66                 if( ret == NULL )
 67                 {
 68                     ret = find(node->left, obj);
 69                 }
 70 
 71                 if( ret == NULL )
 72                 {
 73                     ret = find(node->right, obj);
 74                 }
 75             }
 76         }
 77 
 78         return ret;
 79     }
 80 
 81     virtual bool insert(BTreeNode<T>* n, BTreeNode<T>* np, BTNodePos pos)
 82     {
 83         bool ret = true;
 84 
 85         if( pos == ANY )
 86         {
 87             if( np->left == NULL )
 88             {
 89                 np->left = n;
 90             }
 91             else if( np->right == NULL )
 92             {
 93                 np->right = n;
 94             }
 95             else
 96             {
 97                 ret = false;
 98             }
 99         }
100         else if( pos == LEFT )
101         {
102             if( np->left == NULL )
103             {
104                 np->left = n;
105             }
106             else
107             {
108                 ret = false;
109             }
110         }
111         else if( pos == RIGHT )
112         {
113             if( np->right == NULL )
114             {
115                 np->right = n;
116             }
117             else
118             {
119                 ret = false;
120             }
121         }
122         else
123         {
124             ret = false;
125         }
126 
127         return ret;
128     }
129 
130     virtual void remove(BTreeNode<T>* node, BTree<T>*& ret)
131     {
132         ret = new BTree<T>();
133 
134         if( ret == NULL )
135         {
136             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create btree...");
137         }
138         else
139         {
140             if( root() == node )
141             {
142                 this->m_root = NULL;
143             }
144             else
145             {
146                 BTreeNode<T>* parent = dynamic_cast<BTreeNode<T>*>(node->parent);
147 
148                 if( parent->left == node )
149                 {
150                     parent->left = NULL;
151                 }
152                 else if( parent->right == node )
153                 {
154                     parent->right = NULL;
155                 }
156 
157                 node->parent = NULL;
158             }
159 
160             ret->m_root = node;  //作为子树返回
161         }
162     }
163 
164     virtual void free(BTreeNode<T>* node)
165     {
166         if( node != NULL )
167         {
168             free(node->left);
169             free(node->right);
170 
171             if( node->flag() )
172             {
173                 delete node;
174             }
175         }
176     }
177     #if 0
178     int count(BTreeNode<T>* node) const
179     {
180         int ret = 0;
181 
182         if( node != NULL )
183         {
184             ret = count(node->left) + count(node->right) + 1;
185         }
186 
187         return ret;
188     }
189     #endif
190 
191     int count(BTreeNode<T>* node) const
192     {
193         return (node != NULL) ? (count(node->left) + count(node->right) + 1) : 0;
194     }
195 
196     int height(BTreeNode<T>* node) const
197     {
198         int ret = 0;
199 
200         if( node != NULL )
201         {
202             int lh = height(node->left);
203             int rh = height(node->right);
204 
205             ret = ((lh > rh) ? lh : rh) + 1;;
206         }
207 
208         return ret;
209     }
210 
211 #if 0
212     int degree(BTreeNode<T>* node) const
213     {
214         int ret = 0;
215 
216         if( node != NULL )
217         {
218             int dl = degree(node->left);
219             int dr = degree(node->right);
220 
221             ret = (!!node->left + !!node->right);
222 
223             if( ret < dl )
224             {
225                 ret = dl;
226             }
227 
228             if( ret < dr )
229             {
230                 ret = dr;
231             }
232         }
233 
234         return ret;
235     }
236 #endif
237 //二叉树的最大度数为2，上面的实现效率太低
238     int degree(BTreeNode<T>* node) const
239     {
240         int ret = 0;
241 
242         if( node != NULL )
243         {
244             BTreeNode<T>* child[] = {node->left, node->right};
245 
246             ret = (!!node->left + !!node->right);
247 
248             for( int i = 0; (i < 2) && (ret < 2); i++)
249             {
250                 int d = degree(child[i]);
251 
252                 if( ret < d )
253                 {
254                     ret = d;
255                 }
256             }
257         }
258 
259         return ret;
260     }
261 
262     void preOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue)
263     {
264         if( node != NULL )
265         {
266             queue.add(node);
267             preOrderTraversal(node->left, queue);
268             preOrderTraversal(node->right, queue);
269         }
270     }
271 
272     void inOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue)
273     {
274         if( node != NULL )
275         {
276             inOrderTraversal(node->left, queue);
277             queue.add(node);
278             inOrderTraversal(node->right, queue);
279         }
280     }
281 
282     void postOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue)
283     {
284         if( node != NULL )
285         {
286             postOrderTraversal(node->left, queue);
287             postOrderTraversal(node->right, queue);
288             queue.add(node);
289         }
290     }
291 
292     BTreeNode<T>* clone(BTreeNode<T>* node) const
293     {
294         BTreeNode<T>* ret = NULL;
295 
296         if( node != NULL )
297         {
298             ret = BTreeNode<T>::NewNode();
299 
300             if( ret != NULL )
301             {
302                 ret->value = node->value;
303 
304                 ret->left = clone(node->left);
305                 ret->right = clone(node->right);
306 
307                 if( ret->left != NULL )
308                 {
309                     ret->left->parent = ret;
310                 }
311 
312                 if( ret->right != NULL )
313                 {
314                     ret->right->parent = ret;
315                 }
316             }
317             else
318             {
319                 THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create node...");
320             }
321         }
322 
323         return ret;
324     }
325 
326     bool equal(BTreeNode<T>* lh, BTreeNode<T>* rh) const
327     {
328         if( lh == rh )
329         {
330             return true;
331         }
332         else if( (lh != NULL) && (rh != NULL) )
333         {
334             return (lh->value == rh->value) && equal(lh->left, rh->left) && equal(lh->right, rh->right);
335         }
336         else
337         {
338             return false;
339         }
340     }
341 
342     BTreeNode<T>* add(BTreeNode<T>* lh, BTreeNode<T>* rh) const
343     {
344         BTreeNode<T>* ret = NULL;
345 
346         if( (lh == NULL) && (rh != NULL) )
347         {
348             ret = clone(rh);
349         }
350         else if( (lh != NULL) && (rh == NULL) )
351         {
352             ret = clone(lh);
353         }
354         else if( (lh != NULL) && (rh != NULL) )
355         {
356             ret = BTreeNode<T>::NewNode();
357 
358             if( ret != NULL )
359             {
360                 ret->value = lh->value + rh->value;
361 
362                 ret->left = add(lh->left, rh->left);
363                 ret->right = add(lh->right, rh->right);
364 
365                 if( ret->left != NULL )
366                 {
367                     ret->left->parent = ret;
368                 }
369 
370                 if( ret->right != NULL )
371                 {
372                     ret->right->parent = ret;
373                 }
374             }
375             else
376             {
377                 THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create tree...");
378             }
379         }
380 
381         return ret;
382     }
383 public:
384     bool insert(TreeNode<T>* node)
385     {
386         return insert(node, ANY);
387     }
388 
389     virtual bool insert(TreeNode<T>* node, BTNodePos pos)
390     {
391         bool ret = true;
392 
393         if( node != NULL )
394         {
395             if( this->m_root == NULL )  //空树
396             {
397                 node->parent = NULL;
398                 this->m_root = node;
399             }
400             else
401             {
402                 BTreeNode<T>* np = find(node->parent);
403 
404                 if( np != NULL )
405                 {
406                     ret = insert(dynamic_cast<BTreeNode<T>*>(node), np, pos);
407                 }
408                 else
409                 {
410                     THROW_EXCEPTION(InvalidParameterException, "invalid parent tree node...");
411                 }
412             }
413         }
414         else
415         {
416             THROW_EXCEPTION(InvalidParameterException, "parameter node can not be null...");
417         }
418 
419         return ret;
420     }
421 
422     bool insert(const T& value, TreeNode<T>* parent)
423     {
424         return insert(value, parent, ANY);
425     }
426 
427     virtual bool insert(const T& value, TreeNode<T>* parent, BTNodePos pos)
428     {
429         bool ret = true;
430         BTreeNode<T>* node = BTreeNode<T>::NewNode();
431 
432         if( node == NULL )
433         {
434             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create node...");
435         }
436         else
437         {
438             node->value = value;
439             node->parent = parent;
440 
441             ret = insert(node, pos);
442 
443             if( !ret )
444             {
445                 delete node;
446             }
447         }
448 
449         return ret;
450     }
451 
452     SharedPointer< Tree<T> > remove(TreeNode<T>* node) //删除的节点的子节点我们还需要处理，因此要返回删除节点的指针，//这样有机会对里面的元素做进一步操作
453     {
454         BTree<T>* ret = NULL;
455 
456         node = find(node);
457 
458         if( node == NULL )
459         {
460             THROW_EXCEPTION(InvalidParameterException, "parameter is invalid...");
461         }
462         else
463         {
464             remove(dynamic_cast<BTreeNode<T>*>(node), ret);
465 
466             m_queue.clear();
467         }
468 
469         return ret;
470     }
471 
472     SharedPointer< Tree<T> > remove(const T& value)
473     {
474         BTree<T>* ret = NULL;
475 
476         BTreeNode<T>* node = find(value);
477 
478         if( node == NULL )
479         {
480             THROW_EXCEPTION(InvalidParameterException, "can not find node via value...");
481         }
482         else
483         {
484             remove(node, ret);
485 
486             m_queue.clear();
487         }
488 
489         return ret;
490     }
491 
492     BTreeNode<T>* find(const T& value) const
493     {
494         return find(root(), value);
495     }
496 
497     BTreeNode<T>* find(TreeNode<T>* node) const
498     {
499         return find(root(), dynamic_cast<BTreeNode<T>*>(node));
500     }
501 
502     BTreeNode<T>* root() const
503     {
504         return dynamic_cast<BTreeNode<T>*>(this->m_root);
505     }
506 
507     int degree() const
508     {
509         return degree(root());
510     }
511 
512     int count() const
513     {
514         return count(root());
515     }
516 
517     int height() const
518     {
519         return height(root());
520     }
521 
522     void clear()
523     {
524         free(root());
525 
526         m_queue.clear();
527 
528         this->m_root = NULL;
529     }
530 
531     bool begin()
532     {
533         bool ret = ( root() != NULL );
534 
535         if( ret )
536         {
537             m_queue.clear();
538             m_queue.add(root());
539         }
540 
541         return ret;
542     }
543 
544     bool end()
545     {
546         return (m_queue.length() == 0);
547     }
548 
549     bool next()
550     {
551         bool ret = (m_queue.length() > 0);
552 
553         if( ret )
554         {
555             BTreeNode<T>* node = m_queue.front();
556 
557             m_queue.remove();  //将对头元素出队，相当于移动游标
558 
559             if( node->left != NULL )
560             {
561                 m_queue.add(node->left);
562             }
563 
564             if( node->right )
565             {
566                 m_queue.add(node->right);
567             }
568         }
569 
570         return ret;
571     }
572 
573     T current()
574     {
575         if( !end() )  //遍历的过程当中调用current函数才有意义
576         {
577             return m_queue.front()->value;
578         }
579         else
580         {
581             THROW_EXCEPTION(InvalidOperationException, "No value at current position...");
582         }
583     }
584 
585     SharedPointer< Array<T> > traversal(BTTraversal order)
586     {
587         DynamicArray<T>* ret = NULL;
588         LinkQueue<BTreeNode<T>*> queue;
589 
590         switch( order ){
591         case PreOrder:
592             preOrderTraversal(root(), queue);
593             break;
594         case InOrder:
595             inOrderTraversal(root(), queue);
596             break;
597         case PostOrder:
598             postOrderTraversal(root(), queue);
599             break;
600         default:
601             THROW_EXCEPTION(InvalidParameterException, "parameter is invalid...");
602             break;
603         }
604 
605         ret = new DynamicArray<T>(queue.length());
606         //遍历完将结果保存到动态数组中去
607         if( ret != NULL )
608         {
609             for(int i = 0; i < ret->length(); i++, queue.remove())
610             {
611                 ret->set(i, queue.front()->value);
612             }
613         }
614         else
615         {
616             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create array...");
617         }
618 
619         return ret;
620     }
621 
622     SharedPointer< BTree<T> > clone() const
623     {
624         BTree<T>* ret = new BTree<T>();
625 
626         if( ret != NULL )
627         {
628             ret->m_root = clone(root());
629         }
630         else
631         {
632             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new btree...");
633         }
634 
635         return ret;
636     }
637 
638     bool operator == (const BTree<T>& btree)
639     {
640         return equal(root(), btree.root());
641     }
642 
643     bool operator != (const BTree<T>& btree)
644     {
645         return !(*this == btree);
646     }
647 
648     SharedPointer< BTree<T> > add(const BTree<T>& btree) const
649     {
650         BTree<T>* ret = new BTree<T>();
651 
652         if( ret != NULL )
653         {
654             ret->m_root = add(root(), btree.root());
655         }
656         else
657         {
658             THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new tree...");
659         }
660 
661         return ret;
662     }
663 
664     ~BTree()
665     {
666         clear();
667     }
668 };
669 
670 }
671 
672 #endif // BTREE_H

测试程序如下：

  1 #include <iostream>
  2 #include "GTree.h"
  3 #include "GTreeNode.h"
  4 #include "BTree.h"
  5 #include "BTreeNode.h"
  6 
  7 
  8 using namespace std;
  9 using namespace DTLib;
 10 
 11 
 12 int main()
 13 {
 14     BTree<int> bt;
 15     BTreeNode<int>* n = NULL;
 16 
 17     bt.insert(1, NULL);
 18 
 19     n = bt.find(1);
 20     bt.insert(2, n);
 21     bt.insert(3, n);
 22 
 23     n = bt.find(2);
 24     bt.insert(4, n);
 25     bt.insert(5, n);
 26 
 27     n = bt.find(4);
 28     bt.insert(8, n);
 29     bt.insert(9, n);
 30 
 31     n = bt.find(5);
 32     bt.insert(10, n);
 33 
 34     n = bt.find(3);
 35     bt.insert(6, n);
 36     bt.insert(7, n);
 37 
 38 
 39     cout << bt.count() << endl;
 40     cout << bt.height() << endl;
 41     cout << bt.degree() << endl;
 42 
 43     SharedPointer< BTree<int> > btClone = bt.clone();
 44 
 45     int a[] = {8, 9, 10, 7};
 46 
 47     cout << "Clone: " << endl;
 48     for(int i = 0; i < 5; i++)
 49     {
 50         TreeNode<int>* node = btClone->find(a[i]);
 51 
 52         while( node )
 53         {
 54             cout << node->value << " ";
 55             node = node->parent;
 56         }
 57 
 58         cout << endl;
 59     }
 60 
 61     cout << "Old tree: " << endl;
 62     for(int i = 0; i < 5; i++)
 63     {
 64         TreeNode<int>* node = bt.find(a[i]);
 65 
 66         while( node )
 67         {
 68             cout << node->value << " ";
 69             node = node->parent;
 70         }
 71 
 72         cout << endl;
 73     }
 74 
 75     cout << "bt == *btClone : " << (bt == *btClone) << endl;
 76 
 77     BTree<int> nbt;
 78 
 79     nbt.insert(0, NULL);
 80 
 81     n = nbt.find(0);
 82     nbt.insert(6, n);
 83     nbt.insert(2, n);
 84 
 85     n = nbt.find(2);
 86     nbt.insert(7, n);
 87     nbt.insert(8, n);
 88 
 89     SharedPointer< BTree<int> > r = bt.add(nbt);
 90 
 91     int b[] = {8, 9, 10, 13, 15};
 92 
 93     cout << "Add result: " << endl;
 94 
 95     for(int i = 0; i < 5; i++)
 96     {
 97         TreeNode<int>* node = r->find(b[i]);
 98 
 99         while( node )
100         {
101             cout << node->value << " ";
102             node = node->parent;
103         }
104 
105         cout << endl;
106     }
107 
108     cout << "PreOrder :" << endl;
109     SharedPointer< Array<int> > tr = r->traversal(PreOrder);
110 
111     for(int i = 0; i < tr->length(); i++)
112     {
113         cout << (*tr)[i] << " ";
114     }
115 
116     cout << endl;
117 
118     return 0;
119 }

结果如下：

小结：

查看全文

相关阅读:
kubuntu设置
 odoo git环境搭建
 ubuntu Gnome 14.10添加打印机
 ubuntu 14.10安装Balsamiq Mockups
elementary os luna安装配置
 OpenERP QWeb模板标签笔记
 pycharm3 注册码
 统计项目代码
 odoo filter 日期
 opencart 安装

原文地址：https://www.cnblogs.com/wanmeishenghuo/p/9695080.html

第六十八课 二叉树的比较与相加

第六十八课二叉树的比较与相加