第十一周项目1 -验证算法（1）-层次遍历算法的验证

/*  
 * Copyright (c) 2016, 烟台大学计算机与控制工程学院  
 * All rights reserved。  
 * 文件名称 ：1.cpp  
 * 作    者 ：杨俊杰  
 * 完成日期 ：2016年 11月10日  
 * 版 本 号 ：v1.0  
 * 问题描述 ：实现二叉树的层次遍历算法，并对用”A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”创建的二叉树进行测试。
 * 输入描述 ：
 * 输出描述 ：
 */

[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  
23. 
    
    [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函数，完成相关的测试工作。  
    2. #include <stdio.h>  
    3. #include "btree.h"  
    4.   
    5. void LevelOrder(BTNode *b)  
    6. {  
    7.     BTNode *p;  
    8.     BTNode *qu[MaxSize];    //定义环形队列,存放节点指针  
    9.     int front,rear; //定义队头和队尾指针  
    10.     front=rear=-1;      //置队列为空队列  
    11.     rear++;  
    12.     qu[rear]=b;     //根节点指针进入队列  
    13.     while (front!=rear) //队列不为空  
    14.     {  
    15.         front=(front+1)%MaxSize;  
    16.         p=qu[front];        //队头出队列  
    17.         printf("%c ",p->data);  //访问节点  
    18.         if (p->lchild!=NULL)    //有左孩子时将其进队  
    19.         {  
    20.             rear=(rear+1)%MaxSize;  
    21.             qu[rear]=p->lchild;  
    22.         }  
    23.         if (p->rchild!=NULL)    //有右孩子时将其进队  
    24.         {  
    25.             rear=(rear+1)%MaxSize;  
    26.             qu[rear]=p->rchild;  
    27.         }  
    28.     }  
    29. }  
    30.   
    31. int main()  
    32. {  
    33.     BTNode *b;  
    34.     CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");  
    35.     printf("二叉树b: ");  
    36.     DispBTNode(b);  
    37.     printf("\n");  
    38.     printf("层次遍历序列:");  
    39.     LevelOrder(b);  
    40.     printf("\n");  
    41.     DestroyBTNode(b);  
    42.     return 0;  
    43. }  

    运算结果：