第九周 广义表算法库及应用

问题及代码：

glist.h：


#include <stdio.h>
#include <malloc.h>
typedef char ElemType;
typedef struct lnode
{
    int tag;                             //标识节点类型
    union
    {
        ElemType data;                   //原子值
        struct lnode *sublist;           //指向子表的指针
    }val;
    struct lnode *link;                  //指向下一元素
}GLNode;                                 //定义 广义表节点类型

int GLLength(GLNode *g);                 //求广义表g的长度
int GLDepth(GLNode *g);                  //求广义表g的深度
GLNode *CreateGL(char *&s);              //返回由括号表示法表示s的广义表链式存储结构
void DispGL(GLNode *g);                  //输出广义表g
glist.cpp：


#include "glist.h"
int GLLength(GLNode *g)                 //求广义表g的长度
{
    int len=0;
    GLNode *g1;
    g1=g->val.sublist;
    while(g1!=NULL)
    {
        len++;
        g1=g1->link;
    }
    return len;
}
int GLDepth(GLNode *g)                  //求广义表g的深度
{
    GLNode *g1;
    int max=0,dep;
    if(g->tag==0)                       //原子返回0
        return 0;
    g1=g->val.sublist;                  //g1指向第一个元素
    if(g1==NULL)                        //空表返回1
        return 1;
    while(g1!=NULL)                     //遍历表中每一个元素
    {
        if(g1->tag==1)                  //元素为子表的情况
        {
            dep=GLDepth(g1);            //递归调用求子表深度
            if(dep>max)                 //max为同一层所求过的子表中深度的最大值
                max=dep;
        }
        g1=g1->link;                    //g1指向下一元素
    }
    return (max+1);
}
GLNode *CreateGL(char *&s)              //返回由括号表示法表示s的广义表链式存储结构
{
    GLNode *g;
    char ch=*s++;                       //取一个字符
    if (ch!='\0')                      //串未结束判断
    {
        g=(GLNode *)malloc(sizeof(GLNode));//创建一个新节点
        if (ch=='(')                    //当前字符为左括号时
        {
            g->tag=1;                   //新节点作为表头节点
            g->val.sublist=CreateGL(s); //递归构造子表并链到表头节点
        }
        else if (ch==')')
            g=NULL;                     //遇到')'字符,g置为空
        else if (ch=='#')               //遇到'#'字符，表示为空表
            g=NULL;
        else                            //为原子字符
        {
            g->tag=0;                   //新节点作为原子节点
            g->val.data=ch;
        }
    }
    else                                 //串结束,g置为空
        g=NULL;
    ch=*s++;                            //取下一个字符
    if (g!=NULL)                        //串未结束，继续构造兄弟节点
    {
        if (ch==',')                    //当前字符为','
            g->link=CreateGL(s);        //递归构造兄弟节点
        else                            //没有兄弟了,将兄弟指针置为NULL
            g->link=NULL;
    }

    return g;                           //返回广义表g
}
void DispGL(GLNode *g)                  //输出广义表g
{
    if(g!=NULL)                         //表不为空判断
    {
        if(g->tag==0)                   //g的元素为原子，输出原子值
            printf("%c",g->val.data);
        else                            //g的元素为子表，输出"("
        {
            printf("(");
            if(g->val.sublist==NULL)    //为空表时
                printf("#");
            else
                DispGL(g->val.sublist); //为非空子表时，递归输出子表
            printf(")");
        }
        if(g->link!=NULL)
        {
            printf(",");
            DispGL(g->link);            //递归输出g的兄弟
        }
    }
}
main.cpp：


#include <stdio.h>
#include "glist.h"
int main()
{
    GLNode *g;
    char *s="(b,(b,a,(#),d),((a,b),c((#))))";
    g = CreateGL(s);
    DispGL(g);
    printf("\n广义表长度为：%d\n",GLLength(g));
    printf("广义表深度为：%d\n",GLDepth(g));
    return 0;
}