#数据结构#—广义表

广义表

广义表，又称列表，也是一种线性存储结构。同数组类似，广义表中既可以存储不可再分的元素，也可以存储广义表，记作：

LS = (a1,a2,...,an)

通常，广义表中存储的单个元素称为“原子”，而存储的广义表称为“子表”。
注意，A = () 和 A= (())是不一样的。前者是空表，而后者是包含一个子表的广义表，只不过这个子表是空表。

当广义表不是空表时，称第一个数据（原子或子表）为“表头”，剩下的数据构成的新广义表为“表尾”。
除非广义表为空表，否则广义表一定具有表头和表尾，且广义表的表尾一定是一个广义表。

广义表的存储

由于广义表中既可存储原子（不可再分的数据元素），也可以存储子表，因此很难使用顺序存储结构表示，通常情况下广义表结构采用链表实现。
使用顺序表实现广义表结构，不仅需要操作n维数组（例如{1,{2,{3,4}}}就需要使用三维数组存储），还会造成存储空间的浪费。
使用链表存储广义表，首先需要确定链表中结点的结构。由于广义表中可同事存储原子和子表两种形式的数据，因此链表结点的结构也有两种，如图1 所示：

图1 广义表结点的两种类型

如图1 所示，表示原子的结点由两部分构成，分别是tag标记位和原子的值，表示子表的结点由三部分构成，分别是tag标记位、hp指针和tp指针。

tag标记位勇于区分结点是原子还是子表，通常原子的tag值为0，子表的tag值为1。子表结点中的hp指针用于连接本子表中存储的原子或子表，tp指针用于连接广义表中下一个原子或子表。

因此，广义表中两种节点的C语言表示代码为：

typedef struct GLNode{
  int tag;//标志域
  union{
     char atom;//原子节点的值域
     struct{
        struct GLNode *hp, *tp;
    }prt;//子表结点的指针域，hp指向表头；tp指向表尾
  };
}*Glist;

这里用到了union共用体，因为同一时间此字节不是原子结点就是子表结点，当表示原子结点时，就使用atom变量；反之则使用ptr结构体。

例如，广义表{a,{b,c,d}}是由一个原子a和子表{b,c,d}构成，而子表{b,c,d}又是由原子b、c和d构成，用链表存储该广义表如图2所示：

图2 广义表{a,{b,c,d}}的结构示意图

图2 可以看到，存储原子a、b、c、d时都是用子表包裹着表示的，因为原子a和子表{b,c,d}在广义表中同属一级，而原子b、c、d也同属一级。

图2 中链表存储的广义表用C语言代码表示为：

Glist createGlist(Glist C) {
    //广义表C
    C = (Glist)malloc(sizeof(Glist));
    C->tag = 1;
    //表头原子‘a’
    C->prt.hp = (Glist)malloc(sizeof(Glist));
    C->prt.hp->tag = 0;
    C->prt.hp->atom = 'a';
    //表尾子表{b,c,d},是一个整体
    C->prt.tp = (Glist)malloc(sizeof(Glist));
    C->prt.tp->tag = 1;
    C->prt.tp->prt.hp = (Glist)malloc(sizeof(Glist));
    C->prt.tp->prt.tp = NULL;
    //开始存放下一个数据元素(b,c,d),表头为‘b’，表尾为(c,d)
    C->prt.tp->prt.hp->tag = 1;
    C->prt.tp->prt.hp->prt.hp = (Glist)malloc(sizeof(Glist));
    C->prt.tp->prt.hp->prt.hp->tag = 0;
    C->prt.tp->prt.hp->prt.hp->atom = 'b';
    C->prt.tp->prt.hp->prt.tp = (Glist)malloc(sizeof(Glist));
    //存放子表(c,d),表头为c，表尾为d
    C->prt.tp->prt.hp->prt.tp->tag = 1;
    C->prt.tp->prt.hp->prt.tp->prt.hp = (Glist)malloc(sizeof(Glist));
    C->prt.tp->prt.hp->prt.tp->prt.hp->tag = 0;
    C->prt.tp->prt.hp->prt.tp->prt.hp->atom = 'c';
    C->prt.tp->prt.hp->prt.tp->prt.tp = (Glist)malloc(sizeof(Glist));
    //存放表尾d
    C->prt.tp->prt.hp->prt.tp->prt.tp->tag = 1;
    C->prt.tp->prt.hp->prt.tp->prt.tp->prt.hp = (Glist)malloc(sizeof(Glist));
    C->prt.tp->prt.hp->prt.tp->prt.tp->prt.hp->tag = 0;
    C->prt.tp->prt.hp->prt.tp->prt.tp->prt.hp->atom = 'd';
    C->prt.tp->prt.hp->prt.tp->prt.tp->prt.tp = NULL;
    return C;
}

广义表的另一种存储结构

另一套表示广义表中原子和子表结构的结点，如图3所示：

图3 广义表的另一套结点结构

如图3所示，表示原子的结点构成由tag标记位、原子值和tp指针构成，表示子表的结点还是由tag标记位、hp指针和tp指针构成。

图3的结点结构用C语言代码表示为：

typedef struct GLNode {
    int tag;//标志域
    union{
        int atom;//原子结点的值域
        struct GLNode *hp;//子表结点的指针域，hp指向表头
    };
    struct GLNode *tp;//这里的tp相当于链表的next指针，用于指向下一个数据元素
}*Glist;

采用图3的结点结构存储广义表{a,{b,c,d}}的示意图如图4所示：

图4 广义表{a,{b,c,d}}的存储结构示意图

图4 存储广义表对应的C语言代码为：

Glist createGlist(Glist C) {
    C = (Glist)malloc(sizeof(Glist));
    C->tag = 1;
    C->hp = (Glist)malloc(sizeof(Glist));
    C->tp = NULL;
    //表头原子a
    C->hp->tag = 0;
    C->hp->atom = 'a';
    C->hp->tp = (Glist)malloc(sizeof(Glist));
    C->hp->tp->tag = 1;
    C->hp->tp->hp = (Glist)malloc(sizeof(Glist));
    C->hp->tp->tp = NULL;
    //原子b
    C->hp->tp->hp->tag = 0;
    C->hp->tp->hp->atom = 'b';
    C->hp->tp->hp->tp = (Glist)malloc(sizeof(Glist));
    //原子c
    C->hp->tp->hp->tp->tag = 0;
    C->hp->tp->hp->tp->atom = 'c';
    C->hp->tp->hp->tp->tp = (Glist)malloc(sizeof(Glist));
    //原子d
    C->hp->tp->hp->tp->tp->tag = 0;
    C->hp->tp->hp->tp->tp->atom = 'd';
    C->hp->tp->hp->tp->tp->tp = NULL;
    return C;
}

需要注意的是，无论采用以上哪一种结点结构存储广义表，都不要破坏广义表中数据元素之间的并列关系。拿{a,{b,c,d}}来说，原子a和子表{b,c,d}是并列的，而在子表{b,c,d}中原子b、c、d是并列的。

广义表的深度和长度

广义表的长度，指的是广义表中所包含的数据元素的个数。
由于广义表中可以同时存储原子和子表两种类型的数据，因此在计算广义表的长度时规定，广义表中存储的每个原子算作一个数据，同样每个子表也算作是一个数据。

例如，在广义表{a,{b,c,d}}中，它包含一个原子和一个子表，因此该广义表的长度为2。
再比如，广义表{{a,b}}中只有一个子表{a,b}，因此它的长度为1。
广义表规定，空表{}的长度为0。
在编程实现求广义表长度时，由于广义表的存储使用的是链表结构，有图2和图4两种方式。

对于图2来说，只需计算最顶层含有的结点数量，即可求的广义表的长度。

同理，对于图4来说，由于其最顶层表示的此广义表，而第二层表示的才是该广义表中包含的数据元素，因此可以通过计算第二层中包含的结点数量，既可得广义表的长度。

这里给出计算图2中广义表长度的C语言实现代码：

int GlistLength(Glist C) {
    int number = 0;
    Glist P = C;
    while(P){
        number++;
        P = P->prt.tp;
    }
    return number;
}

广义表的深度

广义表的深度，可以通过观察该表中所包含括号的层数间接得到。

图5 广义表示意图

从图5中可以看到，此广义表从左往右数有两层做括号（从右往左数也是如此），因此此广义表的深度为2。
再比如，广义表{{1,2},{3,{4,5}}}中，子表{1,2}和{3,{4,5}}位于同层，此广义表中包含3层括号，因此深度为3.
以上观察括号的方法需将广义表当做字符串看待，并借助栈存储结构实现。
编写程序计算广义表的深度时，以图2中的广义表为例，可以采用递归的方式：

依次遍历广义表C的每个结点，若当前结点为原子（tag值为0），则返回0；若为空表，则返回1；反之，则继续遍历该子表中的数据元素。
设置一个初始值为0的整型变量max，每次递归过程返回时，令max与返回值进行比较，并取较大值。这样，当整个广义表递归结束时，max+1就是广义表的深度。

其实，每次递归返回的值都是当前所在的子表的深度，原子默认深度为0，空表默认深度为1。
计算图2中广义表深度的C语言实现代码：

int GlistDepth(Glist C) {
    // 如果表C为空表时，直接返回深度1
    if(!C) {
        return 1;
    }
    // 如果表C为原子时，直接返回0
    if(C->tag == 0) {
        return 0;
    }
    int max = 0;// 设置表C的初始深度为0
    for (Glist pp=C; pp; pp=pp->prt.tp) {
        int dep = GlistDepth(pp->prt.hp);
        if(dep > max) {
            max = dep;//每次找到表中遍历到深度最大的表，并用max记录
        }
    }
    // 程序运行到此处，表明广义表不是空表，由于原子返回的是0，而实际长度是1，所以，此处要+1
    return max+1;
}

复制广义表

对于任意一个非空广义表来说，都是由两部分组成：表头和表尾。反之，只要确定的一个广义表的表头和表尾，那么这个广义表就可以唯一确定下来。
复制一个广义表，也是不断的复制表头和表尾的过程。如果表头或者表尾同样是一个广义表，依旧复制其表头和表尾。
所以，复制广义表的过程，其实就是不断的递归，复制广义表中表头和表尾的过程。

递归的出口有两个：

如果当前遍历的数据元素为空表，则直接返回空表。
如果当前遍历的数据元素为该表的一个原子，那么直接复制，返回即可。

针对图2 形式的存储方式，其广义表的复制C语言代码实现：

void copyGlist(Glist C, Glist *T) {
    // 如果C为空表，那么复制表直接为空表
    if(!C) {
        *T = NULL;
    }
    else {
        // C不是空表，给T申请内存空间
        *T = (Glist)malloc(sizeof(Glist));
        // 申请失败，程序停止
        if(!*T){
            exit(0);
        }
        (*T)->tag = C->tag;//复制表C的tag值
        // 判断当前表元素是否为原子，如果是，直接复制
        if(C->tag == 0) {
            (*T)->atom = C->atom;
        }
        else {//复制子表
            copyGlist(C->prt.hp, &((*T)->prt.hp));//复制表头
            copyGlist(C->prt.tp, &((*T)->prt.tp));//复制表尾
        }
    }
}

在实现复制广义表的过程中，实现函数void copyGlist(Glist C, Glist *T);
其中，Glist *T，等同于：struct GLNode* *T，此为二级指针，不是一级指针。在主函数中，调用此函数时，传入的是指针T的地址，而不是T。
这里使用的是地址传递，而不是值传递。如果在这里使用值传递，会导致广义表T丢失结点，复制失败。

摘自C语言中文网—数据结构—广义表