克隆操作也是递归实现的。
添加克隆函数:
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 }
结果如下:
小结: