最基本的二叉树

 

来源：http://blog.csdn.net/hopeyouknow/article/details/6740616?reload

一个最基本的二叉树~~

头文件BiTree.h

[cpp] view plain copy

1. typedef int Item;  
2. typedef struct node  
3. {  
4.     struct node * lchild;  
5.     struct node * rchild;  
6.     Item data;  
7. }BiTNode,*BiTree;  
8.   
9. /*构造一棵新的二叉树*/  
10. BiTree InitBiTree(BiTNode *root);  
11.   
12. /*生成节点*/  
13. BiTNode *MakeNode(Item item,BiTNode *lchild,BiTNode *rchild);  
14. /*释放节点*/  
15. void FreeNode(BiTNode *pnode);  
16.   
17. /*清空一棵二叉树*/  
18. void ClearBiTree(BiTree tree);  
19.   
20. /*销毁一棵二叉树*/  
21. void DestroyBiTree(BiTree tree);  
22.   
23. /*判定是否为空*/  
24. IsEmpty(BiTree tree);  
25.   
26. /*返回树的深度*/  
27. GetDepth(BiTree tree);  
28.   
29. /*返回根*/  
30. BiTree GetRoot(BiTree tree);  
31.   
32. /*返回节点值*/  
33. Item GetItem(BiTNode *pnode);  
34.   
35. /*设置节点值*/  
36. void SetItem(BiTNode *pnode,Item item);  
37.   
38. /*设置左子树*/  
39. BiTree SetLChild(BiTree parent,BiTree lchild);  
40.   
41. /*设置右子树*/  
42. BiTree SetRChild(BiTree parent,BiTree rchild);  
43.   
44. /*返回左子树*/  
45. BiTree GetLChild(BiTree tree);  
46.   
47. /*返回右子树*/  
48. BiTree GetRChild(BiTree tree);  
49.   
50. /*插入新子树*/  
51. BiTree InsertChild(BiTree parent,int lr,BiTree child);  
52.   
53. /*删除子树*/  
54. void DeleteChild(BiTree parent,int lr);  
55.   
56. /*先序遍历二叉树*/  
57. PreOrderTraverse(BiTree tree,void(*visit)());  
58.   
59. /*中序遍历二叉树*/  
60. InOrderTraverse(BiTree tree,void(*visit)());  
61.   
62. /*后序遍历二叉树*/  
63. PostOrderTraverse(BiTree tree,void(*visit)());  

实现文件BiTree.c如下

[cpp] view plain copy

1. #include"BiTree.h"  
2. #include<malloc.h>  
3. #include<stdlib.h>  
4.   
5. /*构造一棵新的二叉树*/  
6. BiTree InitBiTree(BiTNode *root)  
7. {  
8.     BiTree tree = root;  
9.     return tree;  
10. }  
11.   
12. /*生成节点*/  
13. BiTNode *MakeNode(Item item,BiTNode *lchild,BiTNode *rchild)  
14. {  
15.     BiTNode * pnode = (BiTNode *)malloc(sizeof(BiTNode));  
16.     if(pnode)  
17.     {  
18.         pnode->data = item;  
19.         pnode->lchild = lchild;  
20.         pnode->rchild = rchild;  
21.     }  
22.     return pnode;     
23. }  
24.   
25. /*释放节点*/  
26. void FreeNode(BiTNode *pnode)  
27. {  
28.     if(pnode!=NULL)  
29.         free(pnode);  
30. }  
31.   
32. /*清空一棵二叉树*/  
33. void ClearBiTree(BiTree tree)  
34. {  
35.     BiTNode * pnode = tree;  
36.     if(pnode->lchild!=NULL)  
37.         ClearBiTree(pnode->lchild);  
38.   
39.     if(pnode->rchild!=NULL)  
40.         ClearBiTree(pnode->rchild);  
41.   
42.     FreeNode(pnode);  
43. }  
44.   
45. /*销毁一棵二叉树*/  
46. void DestroyBiTree(BiTree tree)  
47. {  
48.     if(tree)  
49.         ClearBiTree(tree);    
50. }  
51.   
52. /*判定是否为空*/  
53. IsEmpty(BiTree tree)  
54. {  
55.     if(tree==NULL)  
56.         return 0;  
57.     else  
58.         return 1;  
59. }  
60.   
61. /*返回树的深度*/  
62. int GetDepth(BiTree tree)  
63. {  
64.     int cd,ld,rd;  
65.     cd = ld = rd = 0;  
66.     if(tree)  
67.     {  
68.         ld = GetDepth(tree->lchild);  
69.         rd = GetDepth(tree->rchild);  
70.         cd = (ld > rd ? ld : rd);  
71.         return cd+1;  
72.     }  
73.     else  
74.         return 0;  
75. }  
76.   
77. /*返回根*/  
78. BiTree GetRoot(BiTree tree)  
79. {  
80.     return tree;  
81. }  
82.   
83. /*返回节点值*/  
84. Item GetItem(BiTNode *pnode)  
85. {  
86.     return pnode->data;  
87. }  
88.   
89. /*设置节点值*/  
90. void SetItem(BiTNode *pnode,Item item)  
91. {  
92.     pnode->data = item;  
93. }  
94.   
95. /*设置左子树*/  
96. BiTree SetLChild(BiTree parent,BiTree lchild)  
97. {  
98.     parent->lchild = lchild;  
99.     return lchild;  
100. }  
101.   
102. /*设置右子树*/  
103. BiTree SetRChild(BiTree parent,BiTree rchild)  
104. {  
105.     parent->rchild = rchild;  
106.     return rchild;  
107. }  
108.   
109. /*返回左子树*/  
110. BiTree GetLChild(BiTree tree)  
111. {  
112.     if(tree)  
113.         return tree->lchild;  
114.     return NULL;  
115. }  
116.   
117. /*返回右子树*/  
118. BiTree GetRChild(BiTree tree)  
119. {  
120.     if(tree)  
121.         return tree->rchild;  
122.     return NULL;  
123. }  
124.   
125. /*插入新子树*/  
126. BiTree InsertChild(BiTree parent,int lr,BiTree child)  
127. {  
128.     if(parent)  
129.     {  
130.         if( lr == 0 && parent->lchild == NULL)  
131.         {  
132.             parent->lchild = child;  
133.             return child;  
134.         }     
135.         if( lr == 1 && parent->rchild == NULL)  
136.         {  
137.             parent->rchild = child;  
138.             return child;  
139.         }     
140.     }  
141.     return NULL;      
142. }  
143.   
144. /*删除子树*/  
145. void DeleteChild(BiTree parent,int lr)  
146. {  
147.     if(parent)  
148.     {  
149.         if( lr == 0 && parent->lchild != NULL)  
150.         {  
151.             parent->lchild = NULL;  
152.             FreeNode(parent->lchild);  
153.         }     
154.         if( lr == 1 && parent->rchild != NULL)  
155.         {  
156.             parent->rchild = NULL;  
157.             FreeNode(parent->rchild);  
158.         }     
159.     }  
160. }  
161.   
162. /*先序遍历二叉树*/  
163. PreOrderTraverse(BiTree tree,void(*visit)())  
164. {  
165.     BiTNode * pnode = tree;  
166.     if(pnode)  
167.     {  
168.         visit(pnode->data);  
169.         PreOrderTraverse(pnode->lchild,visit);  
170.         PreOrderTraverse(pnode->rchild,visit);  
171.     }  
172. }  
173.   
174. /*中序遍历二叉树*/  
175. InOrderTraverse(BiTree tree,void(*visit)())  
176. {  
177.     BiTNode * pnode = tree;  
178.     if(pnode)  
179.     {  
180.         InOrderTraverse(pnode->lchild,visit);  
181.         visit(pnode->data);  
182.         InOrderTraverse(pnode->rchild,visit);  
183.     }  
184. }  
185.   
186. /*后序遍历二叉树*/  
187. PostOrderTraverse(BiTree tree,void(*visit)())  
188. {  
189.     BiTNode * pnode = tree;  
190.     if(pnode)  
191.     {  
192.         PostOrderTraverse(pnode->lchild,visit);        
193.         PostOrderTraverse(pnode->rchild,visit);  
194.         visit(pnode->data);  
195.     }  
196. }  

简单测试程序如下

[cpp] view plain copy

1. 1. #include"BiTree.h"  
   2. #include<stdio.h>  
   3. void print(Item item)  
   4. {  
   5.     printf("%d ",item);  
   6. }  
   7. main()  
   8. {     
   9.     BiTNode * n1 = MakeNode(10,NULL,NULL);  
   10.     BiTNode * n2 = MakeNode(20,NULL,NULL);  
   11.     BiTNode * n3 = MakeNode(30,n1,n2);  
   12.     BiTNode * n4 = MakeNode(40,NULL,NULL);  
   13.     BiTNode * n5 = MakeNode(50,NULL,NULL);  
   14.     BiTNode * n6 = MakeNode(60,n4,n5);  
   15.     BiTNode * n7 = MakeNode(70,NULL,NULL);  
   16.   
   17.     BiTree tree = InitBiTree(n7);  
   18.     SetLChild(tree,n3);  
   19.     SetRChild(tree,n6);  
   20.   
   21.     printf("树的深度为：%d",GetDepth(tree));  
   22.       
   23.     printf("\n先序遍历如下：");  
   24.     PreOrderTraverse(tree,print);  
   25.   
   26.     printf("\n中序遍历如下：");  
   27.     InOrderTraverse(tree,print);  
   28.   
   29.     printf("\n后序遍历如下：");  
   30.     PostOrderTraverse(tree,print);  
   31.   
   32.     DeleteChild(tree,1);  
   33.     printf("\n后序遍历如下：");  
   34.     PostOrderTraverse(tree,print);  
   35.   
   36.     DestroyBiTree(tree);  
   37.     if(IsEmpty(tree))  
   38.      printf("\n二叉树为空，销毁完毕\n");  
   39. }