树之二叉树 图解和代码实现

2013-03-12 16:56 295人阅读 评论(0) 收藏 举报

树之二叉树

 

图解：

 

 

 

以下是代码实现：

 

bitree.h

 

[cpp] view plain copy

1. //声明类BiTree及定义结构BiNode,文件名为bitree.h  
2. #ifndef BITREE_H  
3. #define BITREE_H  
4.   
5. template <class T>  
6. struct BiNode   //二叉树的结点结构  
7. {  
8.   T data;         
9.   BiNode<T> *lchild, *rchild;  
10. };  
11.   
12. template <class T>  
13. class BiTree  
14. {  
15. public:  
16.     BiTree( );             //构造函数，初始化一棵二叉树，其前序序列由键盘输入  
17.     ~BiTree(void);         //析构函数，释放二叉链表中各结点的存储空间  
18.     BiNode<T>* Getroot();  //获得指向根结点的指针  
19.     void PreOrder(BiNode<T> *root);     //前序遍历二叉树  
20.     void InOrder(BiNode<T> *root);      //中序遍历二叉树  
21.     void PostOrder(BiNode<T> *root);    //后序遍历二叉树  
22.     void LeverOrder(BiNode<T> *root);   //层序遍历二叉树  
23. private:  
24.     BiNode<T> *root;         //指向根结点的头指针  
25.     BiNode<T> *Creat( );     //有参构造函数调用  
26.     void Release(BiNode<T> *root);   //析构函数调用   
27. };  
28. #endif  

 

bitree.cpp

 

[cpp] view plain copy

1. //定义类中的成员函数，文件名为bitree.cpp  
2. #include<iostream>  
3. #include<string>  
4. #include"bitree.h"  
5. using namespace std;  
6.   
7. /* 
8.  *前置条件：二叉树不存在 
9.  *输    入：无 
10.  *功    能：构造一棵二叉树 
11.  *输    出：无 
12.  *后置条件：产生一棵二叉树  
13.  */  
14. template<class T>  
15. BiTree<T>::BiTree( )  
16. {  
17.     this->root = Creat( );  
18. }  
19. /* 
20.  *前置条件：二叉树已存在 
21.  *输    入：无 
22.  *功    能：释放二叉链表中各结点的存储空间 
23.  *输    出：无 
24.  *后置条件：二叉树不存在  
25.  */  
26. template<class T>  
27. BiTree<T>::~BiTree(void)  
28. {  
29.     Release(root);  
30. }  
31. /* 
32.  *前置条件：二叉树已存在 
33.  *输    入：无 
34.  *功    能：获取指向二叉树根结点的指针 
35.  *输    出：指向二叉树根结点的指针 
36.  *后置条件：二叉树不变  
37.  */  
38. template<class T>  
39. BiNode<T>* BiTree<T>::Getroot( )  
40. {  
41.     return root;  
42. }  
43. /* 
44.  *前置条件：二叉树已存在 
45.  *输    入：无 
46.  *功    能：前序遍历二叉树 
47.  *输    出：二叉树中结点的一个线性排列 
48.  *后置条件：二叉树不变  
49.  */  
50. template<class T>  
51. void BiTree<T>::PreOrder(BiNode<T> *root)  
52. {  
53.     if(root==NULL)  return;  
54.     else{         
55.         cout<<root->data<<" ";  
56.         PreOrder(root->lchild);  
57.         PreOrder(root->rchild);  
58.     }  
59. }  
60.   
61. /* 
62.  *前置条件：二叉树已存在 
63.  *输    入：无 
64.  *功    能：中序遍历二叉树 
65.  *输    出：二叉树中结点的一个线性排列 
66.  *后置条件：二叉树不变  
67.  */  
68. template <class T>  
69. void BiTree<T>::InOrder (BiNode<T> *root)  
70. {  
71.     if (root==NULL)  return;      //递归调用的结束条件               
72.     else{     
73.         InOrder(root->lchild);    //中序递归遍历root的左子树  
74.         cout<<root->data<<" ";    //访问根结点的数据域  
75.         InOrder(root->rchild);    //中序递归遍历root的右子树  
76.     }  
77. }  
78. /* 
79.  *前置条件：二叉树已存在 
80.  *输    入：无 
81.  *功    能：后序遍历二叉树 
82.  *输    出：二叉树中结点的一个线性排列 
83.  *后置条件：二叉树不变  
84.  */  
85. template <class T>  
86. void BiTree<T>::PostOrder(BiNode<T> *root)  
87. {   
88.     if (root==NULL)   return;       //递归调用的结束条件  
89.     else{     
90.         PostOrder(root->lchild);    //后序递归遍历root的左子树  
91.         PostOrder(root->rchild);    //后序递归遍历root的右子树  
92.         cout<<root->data<<" ";      //访问根结点的数据域  
93.     }  
94. }  
95.   
96. /* 
97.  *前置条件：二叉树已存在 
98.  *输    入：无 
99.  *功    能：层序遍历二叉树 
100.  *输    出：二叉树中结点的一个线性排列 
101.  *后置条件：二叉树不变 
102.  */  
103. template <class T>  
104. void BiTree<T>::LeverOrder(BiNode<T> *root)  
105. {  
106.     const int MaxSize = 100;  
107.   
108.     int front = 0;  
109.     int rear = 0;  //采用顺序队列，并假定不会发生上溢  
110.   
111.     BiNode<T>* Q[MaxSize];  
112.     BiNode<T>* q;  
113.   
114.     if (root==NULL) return;  
115.     else{  
116.         Q[rear++] = root;  
117.         while (front != rear)  
118.         {  
119.             q = Q[front++];  
120.             cout<<q->data<<" ";        
121.             if (q->lchild != NULL)    Q[rear++] = q->lchild;        
122.             if (q->rchild != NULL)    Q[rear++] = q->rchild;  
123.         }  
124.     }  
125. }  
126.   
127. /* 
128.  *前置条件：空二叉树 
129.  *输    入：数据ch; 
130.  *功    能：初始化一棵二叉树,构造函数调用 
131.  *输    出：无 
132.  *后置条件：产生一棵二叉树 
133.  */  
134. template <class T>  
135. BiNode<T>* BiTree<T>::Creat( )  
136. {  
137.     BiNode<T>* root;  
138.     T ch;  
139.     cout<<"请输入创建一棵二叉树的结点数据"<<endl;  
140.     cin>>ch;  
141.     if (ch=="#") root = NULL;  
142.     else{   
143.          root = new BiNode<T>;       //生成一个结点  
144.          root->data=ch;  
145.          root->lchild = Creat( );    //递归建立左子树  
146.          root->rchild = Creat( );    //递归建立右子树  
147.     }   
148.     return root;  
149. }  
150. /* 
151.  *前置条件：二叉树已经存在 
152.  
153.  *输    入：无 
154.  *功    能：释放二叉树的存储空间，析构函数调用 
155.  *输    出：无 
156.  *后置条件：二叉树不存在 
157.  */  
158. template<class T>  
159. void BiTree<T>::Release(BiNode<T>* root)  
160. {  
161.   if (root != NULL){                    
162.       Release(root->lchild);   //释放左子树  
163.       Release(root->rchild);   //释放右子树  
164.       delete root;  
165.   }    
166. }