二叉树常用操作

1. #include <iostream>
2. #include <string>
3. //using namespace std;
5. int n=0,dep1=0,dep2=0,m=0,n1=0,n2=0;
6. template <class T>
7. struct BiNode   //二叉树的结点结构
8. {
9.   T data;       
10.   BiNode<T> *lchild, *rchild;
11. };
13. template <class T>
14. class BiTree
15. {
16. public:
17.     BiTree() {root=NULL;}
18.     BiTree(T ch);             //构造函数，初始化一棵二叉树，其前序序列由键盘输入
19.     ~BiTree(void);         //析构函数，释放二叉链表中各结点的存储空间
20.     BiNode<T>* Getroot();  //获得指向根结点的指针
21.     void PreOrder(BiNode<T> *root);     //前序遍历二叉树
22.     void InOrder(BiNode<T> *root);      //中序遍历二叉树
23.     void PostOrder(BiNode<T> *root);    //后序遍历二叉树
24.     void LeverOrder(BiNode<T> *root);   //层序遍历二叉树
25.     int  Count(BiNode<T> *root);//计算结点个数
26.     int  Depth(BiNode<T> *root);//计算深度
27.     int  leafnum(BiNode<T> *root);//叶子节点个数
28.     int  full(BiNode<T> *root);
29. private:
30.     BiNode<T> *root;         //指向根结点的头指针
31.     BiNode<T> *Creat(T ch);     //有参构造函数调用
32.     void Release(BiNode<T> *root);   //析构函数调用 
33. };
37. template<class T>
38. BiTree<T>::BiTree(T ch)
39. {   cout<<"请输入创建一棵二叉树的结点数据"<<endl;
40.     this->root = Creat(ch);
41. }
45. template <class T>
46. BiNode<T>* BiTree<T>::Creat(T ch)
47. {
48.     BiNode<T>* root;
49.     //T ch;
50.     //cout<<"请输入创建一棵二叉树的结点数据"<<endl;
51.     cin>>ch;
52.     if (ch=="#") root = NULL;
53.     else{ 
54.          root = new BiNode<T>;       //生成一个结点
55.          root->data=ch;
56.          root->lchild = Creat(ch);    //递归建立左子树
57.          root->rchild = Creat(ch);    //递归建立右子树
58.     } 
59.     return root;
60. }
64. template<class T>
65. BiTree<T>::~BiTree(void)
66. {
67.     Release(root);
68. }
71. template<class T>
72. BiNode<T>* BiTree<T>::Getroot( )
73. {
74.     return root;
75. }
78. template<class T>
79. void BiTree<T>::PreOrder(BiNode<T> *root)
80. {
81.     if(root==NULL)  return;
82.     else{       
83.         cout<<root->data<<" ";
84.         PreOrder(root->lchild);
85.         PreOrder(root->rchild);
86.     }
87. }
90. template <class T>
91. void BiTree<T>::InOrder (BiNode<T> *root)
92. {
93.     if (root==NULL)  return;      //递归调用的结束条件             
94.     else{   
95.         InOrder(root->lchild);    //中序递归遍历root的左子树
96.         cout<<root->data<<" ";    //访问根结点的数据域
97.         InOrder(root->rchild);    //中序递归遍历root的右子树
98.     }
99. }
103. template <class T>
104. void BiTree<T>::PostOrder(BiNode<T> *root)
105. { 
106.     if (root==NULL)   return;       //递归调用的结束条件
107.     else{   
108.         PostOrder(root->lchild);    //后序递归遍历root的左子树
109.         PostOrder(root->rchild);    //后序递归遍历root的右子树
110.         cout<<root->data<<" ";      //访问根结点的数据域
111.     }
112. }
115. template <class T>
116. void BiTree<T>::LeverOrder(BiNode<T> *root)
117. {
118.     const int MaxSize = 100;
120.     int front = 0;
121.     int rear = 0;  //采用顺序队列，并假定不会发生上溢
123.     BiNode<T>* Q[MaxSize];
124.     BiNode<T>* q;
126.     if (root==NULL) return;
127.     else{
128.         Q[rear++] = root;
129.         while (front != rear)
130.         {
131.             q = Q[front++];
132.             cout<<q->data<<" ";         
133.             if (q->lchild != NULL)    Q[rear++] = q->lchild;        
134.             if (q->rchild != NULL)    Q[rear++] = q->rchild;
135.         }
136.     }
137. }
141. template<class T>
142. void BiTree<T>::Release(BiNode<T>* root)
143. {
144.   if (root != NULL){                  
145.       Release(root->lchild);   //释放左子树
146.       Release(root->rchild);   //释放右子树
147.       delete root;
148.   }
149. }
151. template<class T>
152. int BiTree<T>::Count(BiNode<T> *root)
153. { 
154.  if(root==NULL) return 0;
155.  else
156.  {
157.   Count(root->lchild);
158.   Count(root->rchild);
159.   n++;
160.  }
161.  return n;
162. }
164. template <class T>
165. int BiTree<T>::Depth(BiNode<T> *root)
166. {
167.  if (root==NULL) return 0;
168.    else
169.    {
170.      dep1=Depth(root->lchild);//计算左子树深度
171.      dep2=Depth(root->rchild);//计算右子树深度
172.      if(dep1>dep2) return dep1+1;
173.         else return dep2+1;
174.    }
176. }
179. template <class T>
180. int BiTree<T>::leafnum(BiNode<T> *root)//叶子节点个数
181. {
182.  if(root==NULL) return 0;
183.  else
184.  {
185.   if(root->lchild==NULL && root->rchild==NULL)
186.       m++;
187.   leafnum(root->lchild);
188.   leafnum(root->rchild);
189.  }
190.   return m;
191. }
195. template <class T>
196. int BiTree<T>::full(BiNode<T> *root)
197. {
198.   if(root==NULL) return 0;
199.     else 
200.     {
201.      if(root->lchild==NULL && root->rchild==NULL)
202.          return 1;
203.      else if (root->lchild==NULL || root->rchild==NULL)
204.          return 0;
205.         else return(full(root->lchild) && full(root->rchild));
206.     }
209. }