第十一周项目1-验证算法（2）-二叉树构造算法的验证

/*  
 * Copyright (c) 2016, 烟台大学计算机与控制工程学院  
 * All rights reserved。  
 * 文件名称 ：1.cpp  
 * 作    者 ：杨俊杰  
 * 完成日期 ：2016年 11月10日  
 * 版 本 号 ：v1.0  
 * 问题描述 ：1.由先序序列和中序序列构造二叉树
                         2.由后序序列和中序序列构造二叉树
 3.由顺序存储结构转为二叉链存储结构 
 * 输出描述 ：

 */

[cpp]  view plain  copy

 

1. //1.头文件：btree.h，包含定义二叉树的链式存储数据结构的代码、宏定义、要实现算法的函数的声明；  
2.   
3. #ifndef BTREE_H_INCLUDED  
4. #define BTREE_H_INCLUDED  
5.   
6. #define MaxSize 100  
7. typedef char ElemType;  
8. typedef struct node  
9. {  
10.     ElemType data;              //数据元素  
11.     struct node *lchild;        //指向左孩子  
12.     struct node *rchild;        //指向右孩子  
13. } BTNode;  
14. void CreateBTNode(BTNode *&b,char *str);        //由str串创建二叉链  
15. BTNode *FindNode(BTNode *b,ElemType x);     //返回data域为x的节点指针  
16. BTNode *LchildNode(BTNode *p);  //返回*p节点的左孩子节点指针  
17. BTNode *RchildNode(BTNode *p);  //返回*p节点的右孩子节点指针  
18. int BTNodeDepth(BTNode *b); //求二叉树b的深度  
19. void DispBTNode(BTNode *b); //以括号表示法输出二叉树  
20. void DestroyBTNode(BTNode *&b);  //销毁二叉树  
21.   
22. #endif // BTREE_H_INCLUDED  

[cpp]  view plain  copy

 

1. //2.源文件：btree.cpp，包含实现各种算法的函数的定义  
2.   
3. #include <stdio.h>  
4. #include <malloc.h>  
5. #include "btree.h"  
6.   
7. void CreateBTNode(BTNode *&b,char *str)     //由str串创建二叉链  
8. {  
9.     BTNode *St[MaxSize],*p=NULL;  
10.     int top=-1,k,j=0;  
11.     char ch;  
12.     b=NULL;             //建立的二叉树初始时为空  
13.     ch=str[j];  
14.     while (ch!='\0')    //str未扫描完时循环  
15.     {  
16.         switch(ch)  
17.         {  
18.         case '(':  
19.             top++;  
20.             St[top]=p;  
21.             k=1;  
22.             break;      //为左节点  
23.         case ')':  
24.             top--;  
25.             break;  
26.         case ',':  
27.             k=2;  
28.             break;                          //为右节点  
29.         default:  
30.             p=(BTNode *)malloc(sizeof(BTNode));  
31.             p->data=ch;  
32.             p->lchild=p->rchild=NULL;  
33.             if (b==NULL)                    //p指向二叉树的根节点  
34.                 b=p;  
35.             else                            //已建立二叉树根节点  
36.             {  
37.                 switch(k)  
38.                 {  
39.                 case 1:  
40.                     St[top]->lchild=p;  
41.                     break;  
42.                 case 2:  
43.                     St[top]->rchild=p;  
44.                     break;  
45.                 }  
46.             }  
47.         }  
48.         j++;  
49.         ch=str[j];  
50.     }  
51. }  
52. BTNode *FindNode(BTNode *b,ElemType x)  //返回data域为x的节点指针  
53. {  
54.     BTNode *p;  
55.     if (b==NULL)  
56.         return NULL;  
57.     else if (b->data==x)  
58.         return b;  
59.     else  
60.     {  
61.         p=FindNode(b->lchild,x);  
62.         if (p!=NULL)  
63.             return p;  
64.         else  
65.             return FindNode(b->rchild,x);  
66.     }  
67. }  
68. BTNode *LchildNode(BTNode *p)   //返回*p节点的左孩子节点指针  
69. {  
70.     return p->lchild;  
71. }  
72. BTNode *RchildNode(BTNode *p)   //返回*p节点的右孩子节点指针  
73. {  
74.     return p->rchild;  
75. }  
76. int BTNodeDepth(BTNode *b)  //求二叉树b的深度  
77. {  
78.     int lchilddep,rchilddep;  
79.     if (b==NULL)  
80.         return(0);                          //空树的高度为0  
81.     else  
82.     {  
83.         lchilddep=BTNodeDepth(b->lchild);   //求左子树的高度为lchilddep  
84.         rchilddep=BTNodeDepth(b->rchild);   //求右子树的高度为rchilddep  
85.         return (lchilddep>rchilddep)? (lchilddep+1):(rchilddep+1);  
86.     }  
87. }  
88. void DispBTNode(BTNode *b)  //以括号表示法输出二叉树  
89. {  
90.     if (b!=NULL)  
91.     {  
92.         printf("%c",b->data);  
93.         if (b->lchild!=NULL || b->rchild!=NULL)  
94.         {  
95.             printf("(");  
96.             DispBTNode(b->lchild);  
97.             if (b->rchild!=NULL) printf(",");  
98.             DispBTNode(b->rchild);  
99.             printf(")");  
100.         }  
101.     }  
102. }  
103. void DestroyBTNode(BTNode *&b)   //销毁二叉树  
104. {  
105.     if (b!=NULL)  
106.     {  
107.         DestroyBTNode(b->lchild);  
108.         DestroyBTNode(b->rchild);  
109.         free(b);  
110.     }  
111. }  

[cpp]  view plain  copy

 

1. //3.在建立算法库过程中，为了完成测试，再同一项目（project）中建立一个源文件(如main.cpp)，编制main函数，完成相关的测试工作。  

[cpp]  view plain  copy

 

1.   

[cpp]  view plain  copy

 

1. //由先序序列和中序序列构造二叉树  
2. #include <stdio.h>  
3. #include <malloc.h>  
4. #include "btree.h"  
5.   
6. BTNode *CreateBT1(char *pre,char *in,int n)  
7. /*pre存放先序序列,in存放中序序列,n为二叉树结点个数, 
8. 本算法执行后返回构造的二叉链的根结点指针*/  
9. {  
10.     BTNode *s;  
11.     char *p;  
12.     int k;  
13.     if (n<=0) return NULL;  
14.     s=(BTNode *)malloc(sizeof(BTNode));     //创建二叉树结点*s  
15.     s->data=*pre;  
16.     for (p=in; p<in+n; p++)                 //在中序序列中找等于*ppos的位置k  
17.         if (*p==*pre)                       //pre指向根结点  
18.             break;                          //在in中找到后退出循环  
19.     k=p-in;                                 //确定根结点在in中的位置  
20.     s->lchild=CreateBT1(pre+1,in,k);        //递归构造左子树  
21.     s->rchild=CreateBT1(pre+k+1,p+1,n-k-1); //递归构造右子树  
22.     return s;  
23. }  
24.   
25. int main()  
26. {  
27.     ElemType pre[]="ABDGCEF",in[]="DGBAECF";  
28.     BTNode *b1;  
29.     b1=CreateBT1(pre,in,7);  
30.     printf("b1:");  
31.     DispBTNode(b1);  
32.     printf("\n");  
33.     return 0;  
34. }  

运行结果：

[cpp]  view plain  copy

 

1. //由后序序列和中序序列构造二叉树  
2. #include <stdio.h>  
3. #include <malloc.h>  
4. #include "btree.h"  
5.   
6. BTNode *CreateBT2(char *post,char *in,int n)  
7. /*post存放后序序列,in存放中序序列,n为二叉树结点个数, 
8. 本算法执行后返回构造的二叉链的根结点指针*/  
9. {  
10.     BTNode *s;  
11.     char r,*p;  
12.     int k;  
13.     if (n<=0) return NULL;  
14.     r=*(post+n-1);                          //根结点值  
15.     s=(BTNode *)malloc(sizeof(BTNode));     //创建二叉树结点*s  
16.     s->data=r;  
17.     for (p=in; p<in+n; p++)                 //在in中查找根结点  
18.         if (*p==r)  
19.             break;  
20.     k=p-in;                                 //k为根结点在in中的下标  
21.     s->lchild=CreateBT2(post,in,k);         //递归构造左子树  
22.     s->rchild=CreateBT2(post+k,p+1,n-k-1);  //递归构造右子树  
23.     return s;  
24. }  
25.   
26. int main()  
27. {  
28.     ElemType in[]="DGBAECF",post[]="GDBEFCA";  
29.     BTNode *b2;  
30.     b2=CreateBT2(post,in,7);  
31.     printf("b2:");  
32.     DispBTNode(b2);  
33.     printf("\n");  
34.     return 0;  
35. }  

运行结果：

[cpp]  view plain  copy

 

1. //由顺序存储结构转为二叉链存储结构   
2. #include <stdio.h>  
3. #include <malloc.h>  
4. #include "btree.h"  
5. #define N 30  
6. typedef ElemType SqBTree[N];  
7. BTNode *trans(SqBTree a,int i)  
8. {  
9.     BTNode *b;  
10.     if (i>N)  
11.         return(NULL);  
12.     if (a[i]=='#')  
13.         return(NULL);           //当节点不存在时返回NULL  
14.     b=(BTNode *)malloc(sizeof(BTNode)); //创建根节点  
15.     b->data=a[i];  
16.     b->lchild=trans(a,2*i);                 //递归创建左子树  
17.     b->rchild=trans(a,2*i+1);               //递归创建右子树  
18.     return(b);                              //返回根节点  
19. }  
20. int main()  
21. {  
22.     BTNode *b;  
23.     ElemType s[]="0ABCD#EF#G####################";  
24.     b=trans(s,1);  
25.     printf("b:");  
26.     DispBTNode(b);  
27.     printf("\n");  
28.     return 0;  
29. }  

运行结果：