二叉树的建立和基本操作

树形结构要多利用递归来求解，递归的关键就是想清楚所有的基准情形，然后扩展到一般情况，写代码的时候最好把基准情况放在前面，把一般情况放在后面！

定义二叉树结构体：

[cpp]  view plain copy

1. typedef struct BinaryTreeNode  
2. {  
3.     TelemType data;  
4.     struct BinaryTreeNode *Left;  
5.     struct BinaryTreeNode *Right;  
6. }Node;  

创建二叉树：

[cpp]  view plain copy

1. Node* createBinaryTree()  
2. {     
3.     Node *p;  
4.     TelemType ch;  
5.     cin>>ch;  
6.     if(ch == 0)     //如果到了叶子节点，接下来的左、右子树分别赋值为0  
7.     {  
8.         p = NULL;  
9.     }  
10.     else  
11.     {  
12.         p = (Node*)malloc(sizeof(Node));  
13.         p->data = ch;  
14.         p->Left  = createBinaryTree();  //递归创建左子树  
15.         p->Right = createBinaryTree();  //递归创建右子树  
16.     }  
17.     return p;  
18. }  

注意：创建二叉树顺序为先中心节点，然后左子树，然后右子树，到了叶子节点后要把它的左右子树分别赋值为0
            比如二叉树为：     1

                                        2                         

           我们输入应为：1 2 0 0 0回车

先序遍历：

[cpp]  view plain copy

1. void preOrderTraverse(Node* root)  
2. {  
3.     if( root )  
4.     {  
5.         cout<<root->data<<' ';  
6.         preOrderTraverse(root->Left);  
7.         preOrderTraverse(root->Right);  
8.     }  
9. }  

中序遍历：

[cpp]  view plain copy

1. void inOrderTraverse(Node* root)  
2. {  
3.     if( root )  
4.     {  
5.         inOrderTraverse(root->Left);  
6.         cout<<root->data<<' ';  
7.         inOrderTraverse(root->Right);  
8.     }  
9. }  

后序遍历：

[cpp]  view plain copy

1. void lastOrderTraverse(Node* root)  
2. {  
3.     if( root )  
4.     {  
5.         lastOrderTraverse(root->Left);  
6.         lastOrderTraverse(root->Right);  
7.         cout<<root->data<<' ';  
8.     }  
9. }  

二叉树节点总数目：

[cpp]  view plain copy

1. int Nodenum(Node* root)  
2. {  
3.     if(root == NULL)  
4.     {  
5.         return 0;  
6.     }  
7.     else  
8.     {  
9.         return 1+Nodenum(root->Left)+Nodenum(root->Right);  
10.   
11.     }  
12. }  

二叉树深度：

[cpp]  view plain copy

1. int DepthOfTree(Node* root)  
2. {  
3.     if(root)  
4.     {  
5.         return DepthOfTree(root->Left)>DepthOfTree(root->Right)?DepthOfTree(root->Left)+1:DepthOfTree(root->Right)+1;  
6.     }  
7.     if( root == NULL )  
8.     {  
9.         return 0;  
10.     }  
11. }  

二叉树叶子节点数：

[cpp]  view plain copy

1. int Leafnum(Node* root)  
2. {  
3.     if(!root)  
4.     {  
5.         return 0;  
6.     }  
7.     else if(  (root->Left == NULL) && (root->Right == NULL) )  
8.     {  
9.         return 1;  
10.     }  
11.     else  
12.     {  
13.         return  (Leafnum(root->Left) + Leafnum(root->Right)) ;  
14.     }  
15. }  

下面是整个程序的代码：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. typedef int TelemType;  
5.   
6. typedef struct BinaryTreeNode  
7. {  
8.     TelemType data;  
9.     struct BinaryTreeNode *Left;  
10.     struct BinaryTreeNode *Right;  
11. }Node;  
12.   
13.   
14. //创建二叉树，顺序依次为中间节点->左子树->右子树  
15. Node* createBinaryTree()  
16. {     
17.     Node *p;  
18.     TelemType ch;  
19.     cin>>ch;  
20.     if(ch == 0)     //如果到了叶子节点，接下来的左、右子树分别赋值为0  
21.     {  
22.         p = NULL;  
23.     }  
24.     else  
25.     {  
26.         p = (Node*)malloc(sizeof(Node));  
27.         p->data = ch;  
28.         p->Left  = createBinaryTree();  //递归创建左子树  
29.         p->Right = createBinaryTree();  //递归创建右子树  
30.     }  
31.     return p;  
32. }  
33.   
34. //先序遍历  
35. void preOrderTraverse(Node* root)  
36. {  
37.     if( root )  
38.     {  
39.         cout<<root->data<<' ';  
40.         preOrderTraverse(root->Left);  
41.         preOrderTraverse(root->Right);  
42.     }  
43. }  
44.   
45. //中序遍历  
46. void inOrderTraverse(Node* root)  
47. {  
48.     if( root )  
49.     {  
50.         inOrderTraverse(root->Left);  
51.         cout<<root->data<<' ';  
52.         inOrderTraverse(root->Right);  
53.     }  
54. }  
55.   
56. //后序遍历  
57. void lastOrderTraverse(Node* root)  
58. {  
59.     if( root )  
60.     {  
61.         lastOrderTraverse(root->Left);  
62.         lastOrderTraverse(root->Right);  
63.         cout<<root->data<<' ';  
64.     }  
65. }  
66.   
67. //二叉树节点总数目  
68. int Nodenum(Node* root)  
69. {  
70.     if(root == NULL)  
71.     {  
72.         return 0;  
73.     }  
74.     else  
75.     {  
76.         return 1+Nodenum(root->Left)+Nodenum(root->Right);  
77.   
78.     }  
79. }  
80.   
81. //二叉树的深度  
82. int DepthOfTree(Node* root)  
83. {  
84.     if(root)  
85.     {  
86.         return DepthOfTree(root->Left)>DepthOfTree(root->Right)?DepthOfTree(root->Left)+1:DepthOfTree(root->Right)+1;  
87.     }  
88.     if( root == NULL )  
89.     {  
90.         return 0;  
91.     }  
92. }  
93.   
94. //二叉树叶子节点数  
95. int Leafnum(Node* root)  
96. {  
97.     if(!root)  
98.     {  
99.         return 0;  
100.     }  
101.     else if(  (root->Left == NULL) && (root->Right == NULL) )  
102.     {  
103.         return 1;  
104.     }  
105.     else  
106.     {  
107.         return  (Leafnum(root->Left) + Leafnum(root->Right)) ;  
108.     }  
109. }  
110.   
111.   
112. int main()  
113. {  
114.     Node *root = NULL;  
115.     root = createBinaryTree();  
116.     printf("二叉树建立成功");  
117.     cout<<endl;  
118.   
119.     cout<<"二叉树总节点数为："<<Nodenum(root)<<endl;  
120.   
121.     cout<<"二叉树深度为："<<DepthOfTree(root)<<endl;  
122.   
123.     cout<<"二叉树叶子节点数为："<<Leafnum(root)<<endl;  
124.   
125.     cout<<"前序遍历结果:"<<endl;  
126.     preOrderTraverse(root);  
127.     cout<<endl;  
128.   
129.     cout<<"中序遍历结果:"<<endl;  
130.     inOrderTraverse(root);  
131.     cout<<endl;  
132.   
133.     cout<<"后序遍历结果:"<<endl;  
134.     lastOrderTraverse(root);  
135.     cout<<endl;  
136.       
137.     return 0;  
138. }  

分别输入两个二叉树来验证结果：

第一个二叉树为：

                                                                                                  
第二个二叉树为：