第九周项目一

1. /*  
2. 烟台大学计算机学院  
3.   
4. 文件名称:xiangmu.cpp  
5.   
6. 作者:刘照京  
7.   
8. 完成日期:2017年11月9日  
9.   
10. 问题描述：定义二叉树的链式存储结构，实现其基本运算，并完成测试 
11.   
12. 输入描述：无 
13.   
14. 输出描述：输出二叉树，查找后结果，左右孩子 
15.   
16. */   
17.   
18.   
19.   
20. //btree.h:  
21.   
22.   
23.   
24. #include <stdio.h>  
25.   
26. typedef char ElemType;  
27.   
28. typedef struct node  
29. {  
30.     ElemType data;  
31.   
32.     struct node *lchild;  
33.   
34.     struct node *rchild;  
35. }BTNode;  
36.   
37. void CreateBTNode(BTNode *&b,char *str);        //由str串创建二叉链  
38. BTNode *FindNode(BTNode *b,ElemType x);     //返回data域为x的节点指针  
39. BTNode *LchildNode(BTNode *p);      //返回*p节点的左孩子节点指针  
40. BTNode *RchildNode(BTNode *p);      //返回*p节点的右孩子节点指针  
41. int BTNodeDepth(BTNode *b);     //求二叉树b的深度  
42. void DispBTNode(BTNode *b);     //以括号表示法输出二叉树  
43. void DestroyBTNode(BTNode *&b);     //销毁二叉树  
44.   
45.   
46. //btree.cpp:  
47.   
48. #include <stdio.h>  
49. #include <malloc.h>  
50. #include "btree.h"  
51. #define MaxSize 100  
52.   
53. void CreateBTNode(BTNode *&b,char *str)  
54. {  
55.     BTNode *St[MaxSize],*p;  
56.   
57.     int top=-1,k,j=0;  
58.   
59.     char ch;  
60.   
61.     b=NULL;  //建立的二叉树初始时为空  
62.   
63.   
64.     ch=str[j];  
65.   
66.     while(ch!='\0') //扫描字符串  
67.     {  
68.         switch(ch)//遇到字母。左右括号，逗号的操作  
69.         {  
70.             case '(':top++;  
71.             St[top]=p;  
72.             k=1;  
73.             break;  
74.             case ')':  
75.                 top--;  
76.                 break;  
77.                 case ',':  
78.                     k=2;  
79.                 break;  
80.                 default:p=(BTNode*)malloc(sizeof(BTNode));  
81.                 p->data=ch;  
82.                 p->lchild=p->rchild=NULL;  
83.                 if(b==NULL)  
84.                 {  
85.                     b=p;  
86.                 }  
87.                 else  
88.                     {  
89.                         switch(k)  
90.                         {  
91.                             case 1:  
92.                             St[top]->lchild=p;  
93.                             break;  
94.                             case 2:  
95.                                 St[top]->rchild=p;  
96.                                 break;  
97.                         }  
98.                     }  
99.          }  
100.          j++;  
101.          ch=str[j];  
102.   
103.     }  
104. }  
105.   
106. void DestroyBTNode(BTNode *&b)  
107. {  
108.     if(b!=NULL)  
109.     {  
110.         DestroyBTNode(b->lchild);//销毁左子树  
111.         DestroyBTNode(b->rchild);//销毁右子树  
112.         free(b);//销毁根结点  
113.   
114.     }  
115. }  
116.   
117. BTNode *FindNode(BTNode *b,ElemType x)  
118. {  
119.     BTNode *p;  
120.     if(b==NULL)  
121.     {  
122.         return NULL;  
123.     }  
124.     else if(b->data==x)  
125.         return b;  
126.     else  
127.         {  
128.             p=FindNode(b->lchild,x);//递归查找该结点  
129.             if(p!=NULL)  
130.             {  
131.                 return p;  
132.             }  
133.             else  
134.                 return FindNode(b->rchild,x);  
135.         }  
136. }  
137.   
138. BTNode *LchildNode(BTNode *p)//求左子树  
139. {  
140.     return p->lchild;  
141. }  
142. BTNode *RchildNode(BTNode *p)//求右子树  
143. {  
144.     return p->rchild;  
145. }  
146.   
147. int BTNodeDepth(BTNode *b)  
148. {  
149.     int lchildh;  
150.   
151.     int rchildh;  
152.   
153.     if(b==NULL)  
154.         return 0;//空树  
155.     else  
156.     {  
157.         lchildh=BTNodeDepth(b->lchild);//递归求根结点左子树  
158.         rchildh=BTNodeDepth(b->rchild);//递归求根结点右子树  
159.         {  
160.             if(lchildh>rchildh)  
161.             {  
162.                 return lchildh+1;  
163.             }  
164.             else  
165.                 {  
166.                     return rchildh+1;  
167.                 }  
168.         }  
169.   
170.   
171.     }  
172. }  
173.   
174. void DispBTNode(BTNode *b)//以括号表示法输出二叉树  
175. {  
176.     if(b!=NULL)  
177.     {  
178.         printf("%c",b->data);  
179.         if(b->lchild!=NULL || b->rchild!=NULL)  
180.         {  
181.             printf("(");  
182.             DispBTNode(b->lchild);  
183.             if(b->rchild!=NULL)  
184.             {  
185.                 printf(",");  
186.                 DispBTNode(b->rchild);  
187.             }  
188.             printf(")");  
189.   
190.         }  
191.     }  
192. }  
193.   
194.   
195. //main:  
196.   
197.   
198. #include <stdio.h>  
199. #include "btree.h"  
200.   
201. int main()  
202. {  
203.     BTNode *p,*lp,*rp;  
204.     BTNode *p1;  
205.     CreateBTNode(p,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");//二叉树建立  
206.     DispBTNode(p);  
207.     if(FindNode(p,'H')!=NULL)  
208.   
209.     {  
210.         p1=FindNode(p,'H');  
211.   
212.   if (p1!=NULL)  
213.     {  
214.         lp=LchildNode(p1);  
215.         if (lp!=NULL)  
216.             printf("\n左孩子为%c\n",lp->data);  
217.         else  
218.             printf("\n无左孩子\n");  
219.         rp=RchildNode(p1);  
220.         if (rp!=NULL)  
221.             printf("右孩子为%c\n",rp->data);  
222.         else  
223.             printf("无右孩子\n");  
224.     }  
225.     else  
226.         printf(" 未找到\n");  
227.   
228.   
229.     }  
230.     printf("%d\n",BTNodeDepth(p));  
231.     printf("销毁树");  
232.   
233.     DestroyBTNode(p);  
234.   
235.     return 0;  
236. }  

运行结果：

学习心得：学会了二叉树的链式存储结构及其基本运算。