项目2 - 二叉树遍历的递归算法

1. /*   
2. Copyright (c)2015,烟台大学计算机与控制工程学院   
3. All rights reserved.   
4. 文件名称：项目2.cbp   
5. 作    者：孙钰坤   
6. 完成日期：2015年11月30日   
7. 版 本 号：v1.0   
8.   
9.    
10. 问题描述：实现二叉树的先序、中序、后序遍历的递归算法，并对用”A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”创建   
11.           的二叉树进行测试。 请利用二叉树算法库。   
12.    
13. 输入描述：无   
14. 程序输出：测试数据   
15. */   

代码：

[csharp]  view plain  copy

1.   
2.  
3. #ifndef BTREE_H_INCLUDED     
4. #define BTREE_H_INCLUDED     
5. #include <stdio.h>     
6. #include <malloc.h>     
7. #define MaxSize 100     
8. typedef char ElemType;    
9. typedef struct node    
10. {    
11.     ElemType data;              //数据元素     
12.     struct node *lchild;        //指向左孩子     
13.     struct node *rchild;        //指向右孩子     
14. } BTNode;    
15. void CreateBTNode(BTNode *&b,char *str);    //由str串创建二叉链     
16. BTNode *FindNode(BTNode *b,ElemType x);     //返回data域为x的节点指针     
17. BTNode *LchildNode(BTNode *p);              //返回*p节点的左孩子节点指针     
18. BTNode *RchildNode(BTNode *p);              //返回*p节点的右孩子节点指针     
19. int BTNodeDepth(BTNode *b);                 //求二叉树b的深度     
20. void DispBTNode(BTNode *b);                 //以括号表示法输出二叉树     
21. void DestroyBTNode(BTNode *&b);             //销毁二叉树     
22. #endif // BTREE_H_INCLUDED    
23.   
24. //二叉树基本运算函数     
25.     
26.     
27. void CreateBTNode(BTNode *&b,char *str)     //由str串创建二叉链     
28. {    
29.     BTNode *St[MaxSize],*p=NULL;    
30.     int top=-1,k,j=0;    
31.     char ch;    
32.     b=NULL;             //建立的二叉树初始时为空     
33.     ch=str[j];    
34.     while (ch!='\0')    //str未扫描完时循环     
35.     {    
36.         switch(ch)    
37.         {    
38.         case '(':    
39.             top++;    
40.             St[top]=p;    
41.             k=1;    
42.             break;      //为左节点     
43.         case ')':    
44.             top--;    
45.             break;    
46.         case ',':    
47.           k=2;    
48.             break;                          //为右节点     
49.         default:    
50.             p=(BTNode *)malloc(sizeof(BTNode));    
51.             p->data=ch;    
52.             p->lchild=p->rchild=NULL;    
53.             if (b==NULL)                    //p指向二叉树的根节点     
54.                 b=p;    
55.             else                            //已建立二叉树根节点     
56.             {    
57.                 switch(k)    
58.                 {    
59.                 case 1:    
60.                     St[top]->lchild=p;    
61.                     break;    
62.                 case 2:    
63.                     St[top]->rchild=p;    
64.                     break;    
65.                 }    
66.             }    
67.         }    
68.         j++;    
69.         ch=str[j];    
70.     }    
71. }    
72. BTNode *FindNode(BTNode *b,ElemType x)  //返回data域为x的节点指针     
73. {    
74.     BTNode *p;    
75.     if (b==NULL)    
76.        return NULL;    
77.     else if (b->data==x)    
78.         return b;    
79.     else    
80.     {    
81.         p=FindNode(b->lchild,x);    
82.         if (p!=NULL)    
83.             return p;    
84.         else    
85.             return FindNode(b->rchild,x);    
86.     }    
87. }    
88. BTNode *LchildNode(BTNode *p)   //返回*p节点的左孩子节点指针     
89. {    
90.     return p->lchild;    
91. }    
92. BTNode *RchildNode(BTNode *p)   //返回*p节点的右孩子节点指针     
93. {    
94.     return p->rchild;    
95. }    
96. int BTNodeDepth(BTNode *b)  //求二叉树b的深度     
97. {    
98.     int lchilddep,rchilddep;    
99.     if (b==NULL)    
100.         return(0);                          //空树的高度为0     
101.     else    
102.    {    
103.         lchilddep=BTNodeDepth(b->lchild);   //求左子树的高度为lchilddep     
104.         rchilddep=BTNodeDepth(b->rchild);   //求右子树的高度为rchilddep     
105.         return (lchilddep>rchilddep)? (lchilddep+1):(rchilddep+1);    
106.     }    
107. }    
108. void DispBTNode(BTNode *b)  //以括号表示法输出二叉树     
109. {    
110.     if (b!=NULL)    
111.     {    
112.         printf("%c",b->data);    
113.         if (b->lchild!=NULL || b->rchild!=NULL)    
114.         {    
115.             printf("(");    
116.             DispBTNode(b->lchild);    
117.             if (b->rchild!=NULL) printf(",");    
118.             DispBTNode(b->rchild);    
119.             printf(")");    
120.         }    
121.     }    
122. }  
123. void DestroyBTNode(BTNode *&b)   //销毁二叉树     
124. {    
125.    if (b!=NULL)    
126.    {    
127.        DestroyBTNode(b->lchild);    
128.        DestroyBTNode(b->rchild);    
129.        free(b);    
130.    }    
131. }    
132.   
133.     
134.     
135.     
136. void PreOrder(BTNode *b)        //先序遍历的递归算法     
137. {    
138.     if (b!=NULL)    
139.     {    
140.         printf("%c ",b->data);  //访问根节点     
141.         PreOrder(b->lchild);    //递归访问左子树     
142.         PreOrder(b->rchild);    //递归访问右子树     
143.     }    
144. }    
145.    
146. void InOrder(BTNode *b)         //中序遍历的递归算法     
147. {    
148.     if (b!=NULL)    
149.    {    
150.         InOrder(b->lchild);     //递归访问左子树     
151.         printf("%c ",b->data);  //访问根节点     
152.        InOrder(b->rchild);     //递归访问右子树     
153.     }    
154. }    
155.     
156. void PostOrder(BTNode *b)       //后序遍历的递归算法     
157. {    
158.     if (b!=NULL)    
159.     {    
160.         PostOrder(b->lchild);   //递归访问左子树     
161.         PostOrder(b->rchild);   //递归访问右子树     
162.         printf("%c ",b->data);  //访问根节点     
163.     }    
164. }    
165.     
166. int main()    
167. {    
168.     BTNode *b;    
169.     CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");    
170.     printf("二叉树b:");    
171.     DispBTNode(b);    
172.     printf("\n");    
173.     printf("先序遍历序列:\n");    
174.     PreOrder(b);    
175.     printf("\n");    
176.     printf("中序遍历序列:\n");    
177.     InOrder(b);    
178.     printf("\n");    
179.     printf("后序遍历序列:\n");    
180.     PostOrder(b);    
181.     printf("\n");    
182.     DestroyBTNode(b);    
183.     return 0;    
184. }