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

其他 2018-09-24 11:57:32 阅读次数: 0

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

添加克隆函数：

  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 }

结果如下：

猜你喜欢

转载自www.cnblogs.com/wanmeishenghuo/p/9695080.html
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022