第十周项目一

/*  

*Copyright  (c)2017,烟台大学计算机与控制工程学院      

*All rights reservrd.            

*作者：zhangsiqi 

*完成时间：2017年11月2日      

*版本号：v1.0      

*问题描述:二叉树算法验证

         运行并重复测试教学内容中涉及的算法。改变测试数据进行重复测试的意义在于，可以从更多角度体会算法，以达到逐渐掌      握算法的程度。使用你的测试数据，并展示测试结果，观察运行结果，以此来领会算法。 

一、层次遍历算法的验证

　　实现二叉树的层次遍历算法，并对用”A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”创建的二叉树进行测试。 

运用二叉树算法库作为基础，建立头文件btree.h

[csharp] view plain copy print ?

1. #ifndef BTREE_H_INCLUDED  
2. #define BTREE_H_INCLUDED  
3.  
4. #define MaxSize 100   
5. typedef char ElemType;  
6. typedef struct node  
7. {  
8.     ElemType data;              //数据元素   
9.     struct node *lchild;        //指向左孩子   
10.     struct node *rchild;        //指向右孩子   
11. } BTNode;  
12. void CreateBTNode(BTNode *&b,char *str);        //由str串创建二叉链   
13. BTNode *FindNode(BTNode *b,ElemType x);     //返回data域为x的节点指针   
14. BTNode *LchildNode(BTNode *p);  //返回*p节点的左孩子节点指针   
15. BTNode *RchildNode(BTNode *p);  //返回*p节点的右孩子节点指针   
16. int BTNodeDepth(BTNode *b); //求二叉树b的深度   
17. void DispBTNode(BTNode *b); //以括号表示法输出二叉树   
18. void DestroyBTNode(BTNode *&b);  //销毁二叉树   
19. void LevelOrder(BTNode *b);  //二叉树的层次遍历算法  
20.  
21. #endif // BTREE_H_INCLUDED  

#ifndef BTREE_H_INCLUDED
#define BTREE_H_INCLUDED

#define MaxSize 100
typedef char ElemType;
typedef struct node
{
    ElemType data;              //数据元素
    struct node *lchild;        //指向左孩子
    struct node *rchild;        //指向右孩子
} BTNode;
void CreateBTNode(BTNode *&b,char *str);        //由str串创建二叉链
BTNode *FindNode(BTNode *b,ElemType x);     //返回data域为x的节点指针
BTNode *LchildNode(BTNode *p);  //返回*p节点的左孩子节点指针
BTNode *RchildNode(BTNode *p);  //返回*p节点的右孩子节点指针
int BTNodeDepth(BTNode *b); //求二叉树b的深度
void DispBTNode(BTNode *b); //以括号表示法输出二叉树
void DestroyBTNode(BTNode *&b);  //销毁二叉树
void LevelOrder(BTNode *b);  //二叉树的层次遍历算法

#endif // BTREE_H_INCLUDED

在源文件btree.cpp中实现各个函数

[csharp] view plain copy print ?

1. #include <stdio.h>  
2. #include <malloc.h>  
3. #include "btree.h"   
4.   
5. void CreateBTNode(BTNode *&b,char *str)     //由str串创建二叉链   
6. {  
7.     BTNode *St[MaxSize],*p=NULL;  
8.     int top=-1,k,j=0;  
9.     char ch;  
10.     b=NULL;             //建立的二叉树初始时为空   
11.     ch=str[j];  
12.     while (ch!='\0')    //str未扫描完时循环   
13.     {  
14.         switch(ch)  
15.         {  
16.         case '(':  
17.             top++;  
18.             St[top]=p;  
19.             k=1;  
20.             break;      //为左节点   
21.         case ')':  
22.             top--;  
23.             break;  
24.         case ',':  
25.             k=2;  
26.             break;                          //为右节点   
27.         default:  
28.             p=(BTNode *)malloc(sizeof(BTNode));  
29.             p->data=ch;  
30.             p->lchild=p->rchild=NULL;  
31.             if (b==NULL)                    //p指向二叉树的根节点   
32.                 b=p;  
33.             else                            //已建立二叉树根节点   
34.             {  
35.                 switch(k)  
36.                 {  
37.                 case 1:  
38.                     St[top]->lchild=p;  
39.                     break;  
40.                 case 2:  
41.                     St[top]->rchild=p;  
42.                     break;  
43.                 }  
44.             }  
45.         }  
46.         j++;  
47.         ch=str[j];  
48.     }  
49. }  
50. BTNode *FindNode(BTNode *b,ElemType x)  //返回data域为x的节点指针   
51. {  
52.     BTNode *p;  
53.     if (b==NULL)  
54.         return NULL;  
55.     else if (b->data==x)  
56.         return b;  
57.     else  
58.     {  
59.         p=FindNode(b->lchild,x);  
60.         if (p!=NULL)  
61.             return p;  
62.         else  
63.             return FindNode(b->rchild,x);  
64.     }  
65. }  
66. BTNode *LchildNode(BTNode *p)   //返回*p节点的左孩子节点指针   
67. {  
68.     return p->lchild;  
69. }  
70. BTNode *RchildNode(BTNode *p)   //返回*p节点的右孩子节点指针   
71. {  
72.     return p->rchild;  
73. }  
74. int BTNodeDepth(BTNode *b)  //求二叉树b的深度   
75. {  
76.     int lchilddep,rchilddep;  
77.     if (b==NULL)  
78.         return(0);                          //空树的高度为0   
79.     else  
80.     {  
81.         lchilddep=BTNodeDepth(b->lchild);   //求左子树的高度为lchilddep   
82.         rchilddep=BTNodeDepth(b->rchild);   //求右子树的高度为rchilddep   
83.         return (lchilddep>rchilddep)? (lchilddep+1):(rchilddep+1);  
84.     }  
85. }  
86. void DispBTNode(BTNode *b)  //以括号表示法输出二叉树   
87. {  
88.     if (b!=NULL)  
89.     {  
90.         printf("%c",b->data);  
91.         if (b->lchild!=NULL || b->rchild!=NULL)  
92.         {  
93.             printf("(");  
94.             DispBTNode(b->lchild);  
95.             if (b->rchild!=NULL) printf(",");  
96.             DispBTNode(b->rchild);  
97.             printf(")");  
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. void LevelOrder(BTNode *b)  
111. {  
112.     BTNode *p;  
113.     BTNode *qu[MaxSize];    //定义环形队列,存放节点指针   
114.     int front,rear; //定义队头和队尾指针   
115.     front=rear=-1;      //置队列为空队列   
116.     rear++;  
117.     qu[rear]=b;     //根节点指针进入队列   
118.     while (front!=rear) //队列不为空   
119.     {  
120.         front=(front+1)%MaxSize;  
121.         p=qu[front];        //队头出队列   
122.         printf("%c ",p->data);  //访问节点   
123.         if (p->lchild!=NULL)    //有左孩子时将其进队   
124.         {  
125.             rear=(rear+1)%MaxSize;  
126.             qu[rear]=p->lchild;  
127.         }  
128.         if (p->rchild!=NULL)    //有右孩子时将其进队   
129.         {  
130.             rear=(rear+1)%MaxSize;  
131.             qu[rear]=p->rchild;  
132.         }  
133.     }  
134. }  

#include <stdio.h>
#include <malloc.h>
#include "btree.h"

void CreateBTNode(BTNode *&b,char *str)     //由str串创建二叉链
{
    BTNode *St[MaxSize],*p=NULL;
    int top=-1,k,j=0;
    char ch;
    b=NULL;             //建立的二叉树初始时为空
    ch=str[j];
    while (ch!='\0')    //str未扫描完时循环
    {
        switch(ch)
        {
        case '(':
            top++;
            St[top]=p;
            k=1;
            break;      //为左节点
        case ')':
            top--;
            break;
        case ',':
            k=2;
            break;                          //为右节点
        default:
            p=(BTNode *)malloc(sizeof(BTNode));
            p->data=ch;
            p->lchild=p->rchild=NULL;
            if (b==NULL)                    //p指向二叉树的根节点
                b=p;
            else                            //已建立二叉树根节点
            {
                switch(k)
                {
                case 1:
                    St[top]->lchild=p;
                    break;
                case 2:
                    St[top]->rchild=p;
                    break;
                }
            }
        }
        j++;
        ch=str[j];
    }
}
BTNode *FindNode(BTNode *b,ElemType x)  //返回data域为x的节点指针
{
    BTNode *p;
    if (b==NULL)
        return NULL;
    else if (b->data==x)
        return b;
    else
    {
        p=FindNode(b->lchild,x);
        if (p!=NULL)
            return p;
        else
            return FindNode(b->rchild,x);
    }
}
BTNode *LchildNode(BTNode *p)   //返回*p节点的左孩子节点指针
{
    return p->lchild;
}
BTNode *RchildNode(BTNode *p)   //返回*p节点的右孩子节点指针
{
    return p->rchild;
}
int BTNodeDepth(BTNode *b)  //求二叉树b的深度
{
    int lchilddep,rchilddep;
    if (b==NULL)
        return(0);                          //空树的高度为0
    else
    {
        lchilddep=BTNodeDepth(b->lchild);   //求左子树的高度为lchilddep
        rchilddep=BTNodeDepth(b->rchild);   //求右子树的高度为rchilddep
        return (lchilddep>rchilddep)? (lchilddep+1):(rchilddep+1);
    }
}
void DispBTNode(BTNode *b)  //以括号表示法输出二叉树
{
    if (b!=NULL)
    {
        printf("%c",b->data);
        if (b->lchild!=NULL || b->rchild!=NULL)
        {
            printf("(");
            DispBTNode(b->lchild);
            if (b->rchild!=NULL) printf(",");
            DispBTNode(b->rchild);
            printf(")");
        }
    }
}
void DestroyBTNode(BTNode *&b)   //销毁二叉树
{
    if (b!=NULL)
    {
        DestroyBTNode(b->lchild);
        DestroyBTNode(b->rchild);
        free(b);
    }
}
void LevelOrder(BTNode *b)
{
    BTNode *p;
    BTNode *qu[MaxSize];    //定义环形队列,存放节点指针
    int front,rear; //定义队头和队尾指针
    front=rear=-1;      //置队列为空队列
    rear++;
    qu[rear]=b;     //根节点指针进入队列
    while (front!=rear) //队列不为空
    {
        front=(front+1)%MaxSize;
        p=qu[front];        //队头出队列
        printf("%c ",p->data);  //访问节点
        if (p->lchild!=NULL)    //有左孩子时将其进队
        {
            rear=(rear+1)%MaxSize;
            qu[rear]=p->lchild;
        }
        if (p->rchild!=NULL)    //有右孩子时将其进队
        {
            rear=(rear+1)%MaxSize;
            qu[rear]=p->rchild;
        }
    }
}

在main.cpp中实现 层次遍历算法的验证

[csharp] view plain copy print ?

1. #include <stdio.h>  
2. #include "btree.h"   
3.   
4. int main()  
5. {  
6.     BTNode *b;  
7.     CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");  
8.     printf("二叉树b: ");  
9.     DispBTNode(b);  
10.     printf("\n");  
11.     printf("层次遍历序列:\n");  
12.     LevelOrder(b);  
13.     DestroyBTNode(b);  
14.     return 0;  
15. }  

#include <stdio.h>
#include "btree.h"

int main()
{
    BTNode *b;
    CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
    printf("二叉树b: ");
    DispBTNode(b);
    printf("\n");
    printf("层次遍历序列:\n");
    LevelOrder(b);
    DestroyBTNode(b);
    return 0;
}

二、 二叉树构造算法的验证

除了btree.h中的函数之外还需要函数

[csharp] view plain copy print ?

1. BTNode *CreateBT1(char *pre,char *in,int n)  
2. {  
3.     BTNode *s;  
4.     char *p;  
5.     int k;  
6.     if (n<=0) return NULL;  
7.     s=(BTNode *)malloc(sizeof(BTNode));     //创建二叉树结点*s   
8.     s->data=*pre;  
9.     for (p=in; p<in+n; p++)                 //在中序序列中找等于*ppos的位置k   
10.         if (*p==*pre)                       //pre指向根结点   
11.             break;                          //在in中找到后退出循环   
12.     k=p-in;                                 //确定根结点在in中的位置   
13.     s->lchild=CreateBT1(pre+1,in,k);        //递归构造左子树   
14.     s->rchild=CreateBT1(pre+k+1,p+1,n-k-1); //递归构造右子树   
15.     return s;  
16. }  

BTNode *CreateBT1(char *pre,char *in,int n)
{
    BTNode *s;
    char *p;
    int k;
    if (n<=0) return NULL;
    s=(BTNode *)malloc(sizeof(BTNode));     //创建二叉树结点*s
    s->data=*pre;
    for (p=in; p<in+n; p++)                 //在中序序列中找等于*ppos的位置k
        if (*p==*pre)                       //pre指向根结点
            break;                          //在in中找到后退出循环
    k=p-in;                                 //确定根结点在in中的位置
    s->lchild=CreateBT1(pre+1,in,k);        //递归构造左子树
    s->rchild=CreateBT1(pre+k+1,p+1,n-k-1); //递归构造右子树
    return s;
}

main函数如下：

[csharp] view plain copy print ?

1. int main()  
2. {  
3.     ElemType pre[]="ABDGCEF",in[]="DGBAECF";  
4.     BTNode *b1;  
5.     b1=CreateBT1(pre,in,7);  
6.     printf("b1:");  
7.     DispBTNode(b1);  
8.     printf("\n");  
9.     return 0;  
10. }