第十周项目一

/*  

*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

  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中实现各个函数

  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中实现 层次遍历算法的验证

  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中的函数之外还需要函数

  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函数如下:

  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. }  
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值