第九周项目一 二叉树的链式存储结构运算

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

运行结果：