二叉树的创建及遍历

最新推荐文章于 2023-04-05 23:16:43 发布
勇敢无畏的活着
最新推荐文章于 2023-04-05 23:16:43 发布
阅读量439
点赞数
分类专栏：数据结构文章标签：二叉树遍历
数据结构专栏收录该内容
14 篇文章 0 订阅
订阅专栏
这里创建二叉树运用了即遍历，都进行了函数的重载，并且遍历的时候，只是顺序的改变；
难点：层次遍历的方法，在这里进行了一下总结。其中包括vector , queue, deque, 等多种方法：
[cpp]view plaincopy 
   
 #include "iostream"  
 #include "vector"  
 #include "malloc.h"  
 #include "queue"  
 using namespace std;  
   
 //二叉树   //先序顺序进行创建  
 template<class Object>  
 class BinaryNode;  
   
 template<class Object>  
 class BinaryTree  
 {  
 private:  
     BinaryNode<Object> *root;   //想要对private进行创建，建立一个重载的函数  
 public:  
     BinaryTree()  
     {  
         root = 0;  
     }  
     ~BinaryTree()  
     {  
         delete root;  
     }  
     void create();    
     bool create(BinaryNode<Object> *&T);  //define 构造二叉树  //递归创建  
       
     //先序，中序，后序，只是输出顺序不同，在操作中递归排列输出顺序。  
     void preOrderTraverse();  
     void inOrderTraverse();  
     void postOrderTraverse();  
     void levelOrderTraverse();  
     void pirntBFS();  
     void printBFS_();  
     void printNodeByLevel();  
     void printNodeByLevel_();  
     bool preOrderTraverse(BinaryNode<Object> *T);   //还可以将遍历完的结点加入到队列中，最后输出。这样就遍历完毕  
     bool inOrderTraverse(BinaryNode<Object> *T);  
     bool postOrderTraverse(BinaryNode<Object> *T);  
     bool levelOrderTraverse(BinaryNode<Object> *T);  
     void pirntBFS(BinaryNode<Object> *root);  
     void printBFS_(BinaryNode<Object> *root);  
     void printNodeByLevel(BinaryNode<Object> *root);  
     void printNodeByLevel_(BinaryNode<Object> *root);  
   
     void *operator new(size_t size);  
     void operator delete(void *p);  
 };  
   
 template<class Object>  
 void* BinaryTree<Object>::operator new(size_t size)  
 {  
     void *p = malloc(size);  
     return p;  
 }  
   
 template<class Object>  
 void BinaryTree<Object>::operator delete(void *p)  
 {  
     free(p);  
 }  
   
 //typedef char Object;  
 template<class Object>  
 class BinaryNode  
 {  
     friend class BinaryTree<Object>;  
 private:  
     Object elem;  
     BinaryNode *leftChild;  
     BinaryNode * rightChild;  
 };  
   
 template<class Object>  
 void BinaryTree<Object>::create()  
 {  
       
     create(root);  
 }  
   
 template<class Object>  
 bool BinaryTree<Object>::create(BinaryNode<Object> *&T)   //指针申请的内存，所以用指向指针的指针或引用  
 {  
     cout << "enter the value of the elem:";  
     Object x;  
     cin >> x;  
     if(x == '#') {T = NULL; delete T;}  
     else  
     {  
         T = new BinaryNode<Object>;   //对外不起作用， //指针参数是如何传递内存的。除非使用指向指针的引用  
         T->elem = x;  
         create(T->leftChild);  
         create(T->rightChild);  
     }  
     return true;  
 }  
   
 template<class Object>  
 void BinaryTree<Object>::preOrderTraverse()  
 {  
     cout << "the preOrder: ";  
     preOrderTraverse(root);  
     cout << endl;  
 }  
 template<class Object>  
 bool BinaryTree<Object>::preOrderTraverse(BinaryNode<Object> *T)  
 {  
     if(T != NULL)  
     {  
         cout << T->elem << " ";  
         preOrderTraverse(T->leftChild);  
         preOrderTraverse(T->rightChild);  
     }  
     return true;  
 }  
   
 template<class Object>  
 void BinaryTree<Object>::inOrderTraverse()  
 {  
     cout << "the inOrder: ";  
     inOrderTraverse(root);  
     cout << endl;  
 }  
 template<class Object>  
 bool BinaryTree<Object>::inOrderTraverse(BinaryNode<Object> *T)  
 {  
     if(T != NULL)  
     {  
         inOrderTraverse(T->leftChild);  
         cout << T->elem << " ";  
         inOrderTraverse(T->rightChild);  
     }  
     return true;  
 }  
   
 template<class Object>  
 void BinaryTree<Object>::postOrderTraverse()  
 {  
     cout << "the postOrder: ";  
     postOrderTraverse(root);  
     cout << endl;  
 }  
 template<class Object>  
 bool BinaryTree<Object>::postOrderTraverse(BinaryNode<Object> *T)  
 {  
     if(T != NULL)  
     {  
         postOrderTraverse(T->leftChild);  
         postOrderTraverse(T->rightChild);  
         cout << T->elem << " ";  
     }  
     return true;  
 }  
   
 /*************************************************************************************************************/  
 //按层次遍历的几种方法  
 //method1:  
 //层次遍历的vector存储模型  
 template<class Object>  
 void BinaryTree<Object>::levelOrderTraverse()  
 {  
     cout <<  "the levelOrder: ";  
     levelOrderTraverse(root);  
 }  
   
 template<class Object>  
 bool BinaryTree<Object>::levelOrderTraverse(BinaryNode<Object> *T)  
 {  
     vector<BinaryNode<Object>*> Node;   //注意定义是结点指针  
     if(T != NULL)  
     {     
         Node.push_back(T);  
         int cur = 0;  
         int last = 1;  
         while(cur < Node.size())  
         {  
             last = Node.size();  
             while(cur < last)  
             {  
                 cout << Node[cur]->elem << " ";  
                 if(Node[cur]->leftChild)  
                     Node.push_back(Node[cur]->leftChild);  
                 if(Node[cur]->rightChild)  
                     Node.push_back(Node[cur]->rightChild);  
                 cur++;  
             }  
         }  
         cout << endl;  
     }  
     return true;  
 }  
   
 //method2:  
 //利用queue双向队列进行实现，  
 template<class Object>  
 void BinaryTree<Object>::printBFS_()  
 {  
     cout << "the level order: ";  
     printBFS_(root);  
 }  
 template<class Object>  
 void BinaryTree<Object>::printBFS_(BinaryNode<Object> *root)  
 {  
     queue<BinaryNode<Object> *> Node;  
     Node.push(root);  
     do  
     {  
         BinaryNode<Object> *node = Node.front(); //第一个结点  
         Node.pop();  
         cout << node->elem << " ";  
         if(node->leftChild)  
             Node.push(node->leftChild);  
         if(node->rightChild)  
             Node.push(node->rightChild);  
     }  
     while(!Node.empty());  
 }  
   
 //mothod3:  
 //换行  
 template<class Object>  
 void BinaryTree<Object>::printNodeByLevel_()  
 {  
     cout << "the level order: ";  
     printNodeByLevel_(root);  
 }  
 template<class Object>  
 void BinaryTree<Object>::printNodeByLevel_(BinaryNode<Object> *root)  
 {  
     deque<BinaryNode<Object> *>Q1, Q2;  
     Q1.push_back(root);  
     do  
     {  
         do  
         {  
             BinaryNode<Object>* node = Q1.front();  
             Q1.pop_front();  
             cout << node->elem << " ";  
             if(node->leftChild)  
                 Q2.push_back(node->leftChild);  
             if(node->rightChild)  
                 Q2.push_back(node->rightChild);  
         }while(!Q1.empty());  
         cout << endl;  
         Q1.swap(Q2);   //exchange the node  
     }while(!Q1.empty());  
 }  
   
   
 //method 4:  
 template<class Object>  
 void BinaryTree<Object>::printNodeByLevel()  
 {  
     cout << "the level order: ";  
     printNodeByLevel(root);  
 }  
 template<class Object>  
 void BinaryTree<Object>::printNodeByLevel(BinaryNode<Object> *root)  
 {  
     queue<BinaryNode<Object> *> Q;  
     Q.push(root);  
     Q.push(0);  
     do  
     {  
         BinaryNode<Object> *node = Q.front();  
         Q.pop();  
         if(node)  
         {  
             cout << node->elem << " ";  
             if(node->leftChild)  
                 Q.push(node->leftChild);   //左压入，没有递归哦  
             if(node->rightChild)  
                 Q.push(node->rightChild);  //右压入  
         }  
         else if(!Q.empty())  //当发现空指针(结束信号)时，要检查队列内是否还有节点，如果没有的话还插入新的结束信号，则会做成死循环  
         {  
             Q.push(0);  
             cout << endl;  
         }  
     }while(!Q.empty());  
 }  
   
 //method5:  
 //多加一个level 成员  
 template<class Object>  
 void BinaryTree<Object>::pirntBFS()  
 {  
     cout << "the level order: ";  
     pirntBFS(root);  
 }  
 template<class Object>  
 void BinaryTree<Object>::pirntBFS(BinaryNode<Object> *root)  
 {  
     queue<BinaryNode<Object> *> Q;  
     Q.push(root);  
     int curlevel = 0;  
     do  
     {  
         BinaryNode<Object> *node = Q.front();  
         int level = node->level;  
         Q.pop();  
         cout << node->elem << " ";  
         if(node->leftChild)  
         {  
             node->leftChild.level = level + 1;  
             Q.push(node->leftChild);  
         }  
         if(node->rightChild)  
         {  
             node->rightChild.level = level + 1;  
             Q.push(node->rightChild);  
         }  
     }  
     while(!Q.empty());  
 }  
 /****************************************************************************************************************/  
   
 int main()  
 {  
     BinaryTree<char> tree;  
     tree.create();  
   
     tree.preOrderTraverse();  //先序遍历  
     tree.inOrderTraverse();   //中序遍历  
     tree.postOrderTraverse(); //后序遍历  
     tree.levelOrderTraverse();//层次遍历  
     tree.printNodeByLevel();  
   
     cin.get();  
     cin.get();  
     return 0;  
 }  
勇敢无畏的活着
关注
0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
二叉树的创建及遍历

这里创建二叉树运用了即遍历，都进行了函数的重载，并且遍历的时候，只是顺序的改变；难点：层次遍历的方法，在这里进行了一下总结。其中包括vector , queue, deque, 等多种方法：[cpp] view plaincopy#include "iostream" #include "vector" #include
复制链接

扫一扫
专栏目录