• 树的孩子兄弟链存储表示创建、遍历等算法

    【实验目的】

    1. 掌握树的孩子兄弟链存储表示。

    2. 掌握树的创建、遍历等算法。

    【问题描述】

    树的创建及其操作。

    【基本要求】

    1. 创建树的孩子兄弟链式存储表示。假设以二元组(F,C)的形式输入一颗树的诸边，其中F表示双亲结点标识，C表示孩子结点标识，且在输入的二元组序列中，C是按层次序列顺序出现的。F=’^’时C为根结点标识，若C也为’^’，则表示输入结束。例如，如下所示树的输入序列为；

              

     

    2. 按树状打印树。例如：假设树上每个结点所含数据元素为单个字母，左下图树印为右下形状。

                                                                            

    3. 统计树的叶子结点个数；

    4. 计算树的高度；

    5. 给出树的先根遍历序列、后根遍历序列和层次遍历序列；

    6. 输出树中从根结点到所有叶子结点的路径。

    【测试数据】

           自行设定

    • 需求分析：包含题目要求，程序功能，运行方式，测试数据等

    题目要求用孩子兄弟链表结构表示树，并按照特定的输入方法去创建树，并将树打印。需要创建结构体CSNode，将数据类型定义为char，在主函数中设置输入，在运行时输入相应的字符，创建孩子兄弟树。

    1. typedef struct CSNode{
    2.     char data;
    3.     struct CSNode *firstchild,*nextsibling;
    4. }CSNode,*CSTree;

     同时先预设队列和相关实现队列操作的函数与结构体，用于实现统计树的叶子结点个数和输出树中从根结点到所有叶子结点的路径。

    1. typedef struct {
    2.     CSTree  *base;  // 动态分配存储空间
    3.     int  front;    // 头指针，若队列不空，指向队列头元素
    4.     int  rear;     // 尾指针，若队列不空，指向队列尾元素的下一个位置
    5. } SqQueue;

    按特定形状打印树：即是按先根遍历去打印树，同时运用递归的方法来打印孩子兄弟，打印孩子时深度加一，打印兄弟时深度不变，所以用一个数字n表示深度，用for循环结合n打印制表符来表示树的深度。

    1. if(T){
    2.         for(int i = 0;i
    3.             cout<<"\t";//按深度打印制表符
    4.         }
    5.         cout<data;//打印数据
    6.         cout<//换行打印孩子
    7.         printTree(T->firstchild,n+1);//递归打印孩子，深度加1
    8.         printTree(T->nextsibling,n);//递归打印兄弟
    9.     }

    二、概要设计：包含抽象数据类型定义，程序模块等

    第一个模块定义CSNode结构体，创建孩子兄弟链表，相应的指针。

        char data;

    通过struct CSNode *firstchild,*nextsibling;可知CSNode是一个递归的结构体。

    定义创建孩子兄弟树，和孩子兄弟树结点的函数。

    1. CSTree GetTreeNode(char ch){//创建结点
    2.     CSTree CST = new CSNode;
    3.     CST->data = ch;
    4.     CST->firstchild = NULL;
    5.     CST->nextsibling = NULL;
    6.     return CST;
    7. }

    创建树，P = GetTreeNode(ch)创建结点，指针入队，fa == ^表示没有父结点，即创建结点为根结点，取队列头元素(指针值)，查询双亲结点，不存在孩子结点时链接第一个孩子结点，否则链接兄弟结点。

    定义顺序队列SqQueue相应的内容，数据，左右孩子指针，头尾指针，创建需要用到的函数，InitQueue构造一个空队列Q；EmptyQueue判断队列是否空；GetHead返回队列Q的队头元素，不修改队头指针；EnQueue插入元素e为Q的新的队尾元素；DeQueue若队列不空，则删除Q的队头元素，否则退出程序报错。相应的需要用到的基本算法，再用这些算法去实现题目所要求的遍历算法和统计结点，路径。

    1. bool EmptyQueue(SqQueue Q){
    2.     //判断队列是否空
    3.     return Q.front == Q.rear;
    4. }
    5.  
    6. int  QueueLength (SqQueue Q) {
    7.     //返回Q的元素个数，即队列的长度
    8.     return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
    9. }
    10.  
    11. CSTree GetHead(SqQueue Q) {
    12.     //返回队列Q的队头元素，不修改队头指针
    13.     if ( Q.front != Q.rear )
    14.         return Q.base[Q.front];
    15.     else
    16.         return 0;
    17. }
    18.  
    19. void EnQueue(SqQueue&Q,CSTree e) {
    20.     // 插入元素e为Q的新的队尾元素
    21.     if((Q.rear+1) %MAXQSIZE ==Q.front){
    22.         cout<<"队列满";
    23.         exit(0); //队列满
    24.     }
    25.     Q.base[Q.rear] = e;
    26.     Q.rear = (Q.rear+1) % MAXQSIZE;
    27. }
    28.  
    29. void DeQueue (SqQueue&Q) {
    30.     //若队列不空，则删除Q的队头元素，
    31.     //否则退出程序报错
    32.     if (Q.front==Q.rear)  exit(0);
    33.     Q.front = (Q.front+1) % MAXQSIZE;
    34. }

    第二个模块用来定义相应的算法, CountLeaf(CSTree T)用于统计树的叶子结点个数，TreeDepth(CSTree T)用于计算树的高度，PreOrderTraverse(CSTree T)先根遍历树，InOrderTraverse(CSTree T)后根遍历树，LevelOrderTraverse(CSTree T)层次遍历树，AllPath(CSTree T,SqQueue Q)用于输出根结点到叶子结点的路径。

           第三个模块是主函数模块，用来实现进入算法和输出函数返回值，输出正确的题目和所要求的结果。同时用于初始化孩子兄弟树与队列，按顺序调用的算法函数和endl，让最后运行程序时简洁美观。

    1. int main()
    2. {
    3.     CSTree CST;SqQueue Q;
    4.     CreatTree(CST);InitQueue(Q);
    5.     printTree(CST,0);
    6.     cout<<"树的叶子个数为:"<<CountLeaf(CST)<
    7.     cout<<"树的高度为:"<<TreeDepth(CST)<
    8.     cout<<"树的先根遍历为:";PreOrderTraverse(CST);cout<
    9.     cout<<"树的后根遍历为:";InOrderTraverse(CST);cout<
    10.     cout<<"树的层次遍历为:";LevelOrderTraverse(CST);cout<
    11.     cout<<"树从根结点到所有叶子结点的路径:"<AllPath(CST,Q);
    12.     return 0;
    13. }
    14. 详细设计：抽象数据类型以及程序模块的具体实现，算法设计思想
    15. 统计树的叶子结点个数：设置静态的int static num做计数数据，当没有没有孩子即为叶子结点，计数+1，否则即是按递归遍历孩子兄弟，最后返回n，即是叶子结点个数。
    16. int CountLeaf(CSTree T){//统计树的叶子结点个数
    17.     int static num=0;
    18.     if(T){
    19.         if(!T->firstchild)//没有孩子即为叶子结点，计数+1
    20.           num++;
    21.         CountLeaf(T->firstchild);//遍历孩子
    22.         CountLeaf(T->nextsibling);//遍历兄弟
    23.     }
    24.     return num;
    25. }
    26. 计算树的高度：空树时返回0，树高度为0。定义h1，h2分别表示孩子、兄弟的高度，并递归计算，返回两者中较大值，即为树的高度。
    27. int TreeDepth(CSTree T){//计算树的高度
    28.     if(T == NULL) return 0;//空树时返回0
    29.     else{
    30.         int h1 = TreeDepth(T->firstchild);//孩子高度
    31.         int h2 = TreeDepth(T->nextsibling);//兄弟高度
    32.         return (h1+1>h2)?(h1+1):h2;//返回大的值
    33.     }
    34. }
    35. 给出树的先根遍历序列、后根遍历序列：先根遍历与后根遍历较为简单，只需要根据遍历的定义按顺序输出孩子兄弟，即输出了相应的序列。
    36. void PreOrderTraverse(CSTree T) {//先根遍历
    37.     if(T) {
    38.         cout<data<<" ";
    39.         PreOrderTraverse(T->firstchild);
    40.         PreOrderTraverse(T->nextsibling);
    41.     }
    42. }
    43.  
    44. void InOrderTraverse(CSTree T) {//后根遍历
    45.     if(T) {
    46.         InOrderTraverse(T->firstchild);
    47.         cout<data<<" ";
    48.         InOrderTraverse(T->nextsibling);
    49.     }
    50. }
    51. 输出树的层次序列：需要用到队列辅助输出层次序列，队列创建并初始化后，先让根结点入队，队列非空时，根据队列长度输出结点并出队，指向下一个孩子结点，在p非空时继续遍历入队，让p指向兄弟结点，循环上述方法直到树遍历完成。
    52. void LevelOrderTraverse(CSTree T){//层次遍历
    53.     SqQueue Q;
    54.     InitQueue(Q);//队列初始化
    55.     if(T==NULL) return;
    56.     CSTree p = T;
    57.     EnQueue(Q,p);//根结点入队
    58.         while (!EmptyQueue(Q)) {
    59.             int width = QueueLength(Q);//队列长度
    60.             for(int i = 0;i
    61.                 p = GetHead(Q);
    62.                 cout<data<<" ";//输出结点
    63.                 DeQueue(Q);//出队
    64.                 p = p->firstchild;//指向下一个孩子结点
    65.                 while (p) {//p非空时继续遍历
    66.                     EnQueue(Q,p);//入队
    67.                     p = p->nextsibling;//指向兄弟结点
    68.                 }
    69.             }
    70.         }
    71. }

    输出树中从根结点到所有叶子结点的路径：同样是要用队列辅助输出，但队列要定义在主函数中，因为要用到递归，队列定义在主函数中保证路径输出正确。根结点入队，当没有孩子时输出路径，否则指向孩子，递归孩子，循环入队直到该路径输出。一条路径输出之后指向根结点兄弟，重复上面的方法，直到所有路径输出完成。

    1. void AllPath(CSTree T,SqQueue Q){//输出根结点到叶子结点的路径
    2.     if(T){
    3.         EnQueue(Q,T);//根结点入队
    4.         if(!T->firstchild){//没有孩子时输出路径
    5.             for(;QueueLength(Q)>1;DeQueue(Q)){
    6.                 cout<<GetHead(Q)->data<<" ";
    7.             }
    8.             cout<<GetHead(Q)->data<
    9.         }else {
    10.             T = T->firstchild;//否则指向孩子
    11.             while (T) {
    12.                 AllPath(T,Q);//递归孩子，即递归该路径
    13.                 T = T->nextsibling;//指向兄弟
    14.             }
    15.         }
    16.     }
    17. }

    四、调试分析：包括算法的时间复杂度和空间复杂度分析等

           树的先根遍历序列、后根遍历用到了递归，时间复杂度均为O（n），辅助空间即树的深度，所以空间复杂度也为O（n）。

    按树状打印孩子兄弟树同理，但因为需要按深度打印制表符，所以时间复杂度为O（n2），空间复杂度为O（n）。

           树的层次遍历，因为需要用到队列，出队和入队，同时需要递归遍历孩子兄弟，辅助空间较多，同时用到队列空间和树CSNode空间，空间复杂度为O（n2），时间复杂度为O（n）。

           统计叶子结点个数的算法较为简单，只使用了递归遍历，对含n个结点的二叉树，时间复杂度均为O（n），辅助空间即树的深度，所以空间复杂度也为O（n）。

    输出根结点到所有叶子结点的路径中，要用到队列，输出队列中的内容，加上需要递归子树，所以时间复杂度为O（n2），空间复杂度也为空间复杂度为O（n2）。

    在层次遍历孩子兄弟树时，没有正确的递归孩子兄弟，递归了传入算法的树，让其入队，相当于重复入队其首结点并输出，导致层次序列一直输出首结点直到队列满，后来发现是需要在递归函数的参数中传入队头的子树，才能正确递归孩子兄弟，这样才正确入队和出队，完成输出层次遍历树的目的。

    统计叶子结点时定义n为全局变量，封装性不够好，在递归时最好定义静态static的数据，这样保证了数据的封装性也保证了输出能够正确，同时不破坏程序的模块化。

    输出根结点到所有叶子结点的路径时，错误的对形参采用了取地址的符号&，导致递归的封装性被破坏，取到队列的未知地址，整个函数的输出完全错误，后来经过仔细检查后发现不能取地址，而是直接对队列进行调整入队，这样才能输出正确的路径。

    五、测试结果：提供试验结果和数据，测试所有操作结果的正确性


    测试数据1:

    可见所有数据正确

    测试数据2：

    可见所有数据正确：

    头文件及源程序

     

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. #define MAXQSIZE  100  //最大队列长度
    7.  
    8. typedef struct CSNode{
    9.     char data;
    10.     struct CSNode *firstchild,*nextsibling;
    11. }CSNode,*CSTree;
    12.  
    13. typedef struct {
    14.     CSTree  *base;  // 动态分配存储空间
    15.     int  front;    // 头指针，若队列不空，指向队列头元素
    16.     int  rear;     // 尾指针，若队列不空，指向队列尾元素的下一个位置
    17. } SqQueue;
    18.  
    19. void InitQueue (SqQueue &Q) {
    20.     // 构造一个空队列Q
    21.     Q.base = new CSTree[MAXQSIZE];
    22.     if(!Q.base) exit(0);             // 存储分配失败
    23.     Q.front = Q.rear = 0;
    24. }
    25.  
    26. bool EmptyQueue(SqQueue Q){
    27.     //判断队列是否空
    28.     return Q.front == Q.rear;
    29. }
    30.  
    31. int  QueueLength (SqQueue Q) {
    32.     //返回Q的元素个数，即队列的长度
    33.     return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
    34. }
    35.  
    36. CSTree GetHead(SqQueue Q) {
    37.     //返回队列Q的队头元素，不修改队头指针
    38.     if ( Q.front != Q.rear )
    39.         return Q.base[Q.front];
    40.     else
    41.         return 0;
    42. }
    43.  
    44. void EnQueue(SqQueue&Q,CSTree e) {
    45.     // 插入元素e为Q的新的队尾元素
    46.     if((Q.rear+1) %MAXQSIZE ==Q.front){
    47.         cout<<"队列满";
    48.         exit(0); //队列满
    49.     }
    50.     Q.base[Q.rear] = e;
    51.     Q.rear = (Q.rear+1) % MAXQSIZE;
    52. }
    53.  
    54. void DeQueue (SqQueue&Q) {
    55.     //若队列不空，则删除Q的队头元素，
    56.     //否则退出程序报错
    57.     if (Q.front==Q.rear)  exit(0);
    58.     Q.front = (Q.front+1) % MAXQSIZE;
    59. }
    60.  
    61. CSTree GetTreeNode(char ch){//创建结点
    62.     CSTree CST = new CSNode;
    63.     CST->data = ch;
    64.     CST->firstchild = NULL;
    65.     CST->nextsibling = NULL;
    66.     return CST;
    67. }
    68.  
    69. void CreatTree(CSTree &T){//创建树
    70.     CSTree P,s,r;
    71.     T = NULL;
    72.     SqQueue Q;InitQueue(Q);//队列创建及初始化
    73.     char fa,ch;
    74.     for(cin>>fa,cin>>ch;ch!='^';cin>>fa,cin>>ch){
    75.         P = GetTreeNode(ch);//创建结点
    76.         EnQueue(Q,P);//指针入队
    77.         if(fa == '^') T=P;//fa == ^表示没有父结点，即创建结点为根结点
    78.         else{//不为根结点时
    79.             s = GetHead(Q);//取队列头元素(指针值)
    80.             while (s->data != fa){//查询双亲结点
    81.                 DeQueue(Q);s = GetHead(Q);
    82.             }
    83.             if(!(s->firstchild)){
    84.                 s->firstchild = P;//链接第一个孩子结点
    85.                 r = P;//r指向尾端
    86.             }else{
    87.                 r->nextsibling = P;//链接兄弟结点
    88.                 r = P;//r指向尾端
    89.             }
    90.         }
    91.     }
    92. }
    93.  
    94. void printTree(CSTree T,int n){//打印树，n表示深度
    95.     if(T){
    96.         for(int i = 0;i
    97.             cout<<"\t";//按深度打印制表符
    98.         }
    99.         cout<data;//打印数据
    100.         cout<//换行打印孩子
    101.         printTree(T->firstchild,n+1);//递归打印孩子，深度加1
    102.         printTree(T->nextsibling,n);//递归打印兄弟
    103.     }
    104. }
    105.  
    106. int CountLeaf(CSTree T){//统计树的叶子结点个数
    107.     int static num=0;
    108.     if(T){
    109.         if(!T->firstchild)//没有孩子即为叶子结点，计数+1
    110.           num++;
    111.         CountLeaf(T->firstchild);//遍历孩子
    112.         CountLeaf(T->nextsibling);//遍历兄弟
    113.     }
    114.     return num;
    115. }
    116.  
    117. int TreeDepth(CSTree T){//计算树的高度
    118.     if(T == NULL) return 0;//空树时返回0
    119.     else{
    120.         int h1 = TreeDepth(T->firstchild);//孩子高度
    121.         int h2 = TreeDepth(T->nextsibling);//兄弟高度
    122.         return (h1+1>h2)?(h1+1):h2;//返回大的值
    123.     }
    124. }
    125.  
    126. void PreOrderTraverse(CSTree T) {//先根遍历
    127.     if(T) {
    128.         cout<data<<" ";
    129.         PreOrderTraverse(T->firstchild);
    130.         PreOrderTraverse(T->nextsibling);
    131.     }
    132. }
    133.  
    134. void InOrderTraverse(CSTree T) {//后根遍历
    135.     if(T) {
    136.         InOrderTraverse(T->firstchild);
    137.         cout<data<<" ";
    138.         InOrderTraverse(T->nextsibling);
    139.     }
    140. }
    141.  
    142. void LevelOrderTraverse(CSTree T){//层次遍历
    143.     SqQueue Q;
    144.     InitQueue(Q);//队列初始化
    145.     if(T==NULL) return;
    146.     CSTree p = T;
    147.     EnQueue(Q,p);//根结点入队
    148.         while (!EmptyQueue(Q)) {
    149.             int width = QueueLength(Q);//队列长度
    150.             for(int i = 0;i
    151.                 p = GetHead(Q);
    152.                 cout<data<<" ";//输出结点
    153.                 DeQueue(Q);//出队
    154.                 p = p->firstchild;//指向下一个孩子结点
    155.                 while (p) {//p非空时继续遍历
    156.                     EnQueue(Q,p);//入队
    157.                     p = p->nextsibling;//指向兄弟结点
    158.                 }
    159.             }
    160.         }
    161. }
    162.  
    163. void AllPath(CSTree T,SqQueue Q){//输出根结点到叶子结点的路径
    164.     if(T){
    165.         EnQueue(Q,T);//根结点入队
    166.         if(!T->firstchild){//没有孩子时输出路径
    167.             for(;QueueLength(Q)>1;DeQueue(Q)){
    168.                 cout<<GetHead(Q)->data<<" ";
    169.             }
    170.             cout<<GetHead(Q)->data<
    171.         }else {
    172.             T = T->firstchild;//否则指向孩子
    173.             while (T) {
    174.                 AllPath(T,Q);//递归孩子，即递归该路径
    175.                 T = T->nextsibling;//指向兄弟
    176.             }
    177.         }
    178.     }
    179. }
    180.  
    181. int main()
    182. {
    183.     CSTree CST;SqQueue Q;
    184.     CreatTree(CST);InitQueue(Q);
    185.     printTree(CST,0);
    186.     cout<<"树的叶子个数为:"<<CountLeaf(CST)<
    187.     cout<<"树的高度为:"<<TreeDepth(CST)<
    188.     cout<<"树的先根遍历为:";PreOrderTraverse(CST);cout<
    189.     cout<<"树的后根遍历为:";InOrderTraverse(CST);cout<
    190.     cout<<"树的层次遍历为:";LevelOrderTraverse(CST);cout<
    191.     cout<<"树从根结点到所有叶子结点的路径:"<AllPath(CST,Q);
    192.     return 0;
    193. }

    仅供参考，求点赞收藏~

  • 相关阅读:
    网络代理技术：保障隐私与增强安全
    Eigen::Matrix 排序
    【Python5】光模块瓦数和温度，tlv，
    递增/递减运算符和指针
    3.51 什么是平坦式原理图？什么是层次式电路设计？它的优点有哪些？
    语法复习之C语言与指针
    1.spring:IOC-ssg
    003 topic
    爬虫系统云平台部署与维护：利用Docker和Kubernetes优化运维
    Linux 基本指令(上)
  • 原文地址：https://blog.csdn.net/qq_52788258/article/details/127837891