什么是广义表-摩杜云开发者社区

什么是广义表

广义表的原子和子表

广义表的表头和表尾

广义表的存储结构详解（包含2种存储方案）

广义表的另一种存储结构

广义表的复制详解（含C语言代码实现）

总结

什么是广义表

广义表(Lists，又称列表)是一种非线性的数据结构，是线性表的一种推广。即广义表中放松对表元素的原子限制，容许它们具有其自身结构（即可以有子表） 。它被广泛的应用于人工智能等领域的表处理语言LISP语言中。在LISP语言中，广义表是一种最基本的数据结构，就连LISP 语言的程序也表示为一系列的广义表

前面讲过，数组即可以存储不可再分的数据元素（如数字 5、字符 'a'），也可以继续存储数组（即 n 维数组）。

但需要注意的是，以上两种数据存储形式绝不会出现在同一个数组中。例如，我们可以创建一个整形数组去存储 {1,2,3}，我们也可以创建一个二维整形数组去存储 {{1,2,3},{4,5,6}}，但数组不适合用来存储类似 {1,{1,2,3}} 这样的数据。

有人可能会说，创建一个二维数组来存储{1,{1,2,3}}。在存储上确实可以实现，但无疑会造成存储空间的浪费。

对于存储 {1,{1,2,3}} 这样的数据，更适合用广义表结构来存储。

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

LS = (a1,a2,…,an)

其中，LS 代表广义表的名称，an 表示广义表存储的数据。广义表中每个 ai 既可以代表单个元素，也可以代表另一个广义表。

广义表的原子和子表

通常，广义表中存储的单个元素称为 "原子"，而存储的广义表称为 "子表"。

例如创建一个广义表 LS = {1,{1,2,3}}，我们可以这样解释此广义表的构成：广义表 LS 存储了一个原子 1 和子表 {1,2,3}。

以下是广义表存储数据的一些常用形式：

A = ()：A 表示一个广义表，只不过表是空的。
B = (e)：广义表 B 中只有一个原子 e。
C = (a,(b,c,d)) ：广义表 C 中有两个元素，原子 a 和子表 (b,c,d)。
D = (A,B,C)：广义表 D 中存有 3 个子表，分别是A、B和C。这种表示方式等同于 D = ((),(e),(b,c,d)) 。
E = (a,E)：广义表 E 中有两个元素，原子 a 和它本身。这是一个递归广义表，等同于：E = (a,(a,(a,…)))。

注意，A = () 和 A = (()) 是不一样的。前者是空表，而后者是包含一个子表的广义表，只不过这个子表是空表。

广义表的表头和表尾

当广义表不是空表时，称第一个数据（原子或子表）为"表头"，剩下的数据构成的新广义表为"表尾"。

强调一下，除非广义表为空表，否则广义表一定具有表头和表尾，且广义表的表尾一定是一个广义表。

例如在广义表中 LS={1,{1,2,3},5} 中，表头为原子 1，表尾为子表 {1,2,3} 和原子 5 构成的广义表，即 {{1,2,3},5}。

再比如，在广义表 LS = {1} 中，表头为原子 1 ，但由于广义表中无表尾元素，因此该表的表尾是一个空表，用 {} 表示。

广义表的存储结构详解（包含2种存储方案）

由于广义表中既可存储原子（不可再分的数据元素），也可以存储子表，因此很难使用顺序存储结构表示，通常情况下广义表结构采**用链表**实现。

使用顺序表实现广义表结构，不仅需要操作 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;
}ptr;//子表结点的指针域，hp指向表头；tp指向表尾
}subNode;
}*Glist;

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

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

什么是广义表_Python_02

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

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

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

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

广义表的另一种存储结构

如果你觉得图 2 这种存储广义表的方式不合理，可以使用另一套表示广义表中原子和子表结构的节点，如图 3 所示：

什么是广义表_Python_03

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

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

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

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

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

什么是广义表_Python_04

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

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

Glist creatGlist(Glist C) {
C = (Glist)malloc(sizeof(GLNode));
C->tag = 1;
C->subNode.hp = (Glist)malloc(sizeof(GLNode));
C->tp = NULL;

//表头原子a
C->subNode.hp->tag = 0;
C->subNode.hp->subNode.atom = 'a';
C->subNode.hp->tp = (Glist)malloc(sizeof(GLNode));

C->subNode.hp->tp->tag = 1;
C->subNode.hp->tp->subNode.hp = (Glist)malloc(sizeof(GLNode));
C->subNode.hp->tp->tp = NULL;

//原子b
C->subNode.hp->tp->subNode.hp->tag = 0;
C->subNode.hp->tp->subNode.hp->subNode.atom = 'b';
C->subNode.hp->tp->subNode.hp->tp = (Glist)malloc(sizeof(GLNode));

//原子c
C->subNode.hp->tp->subNode.hp->tp->tag = 0;
C->subNode.hp->tp->subNode.hp->tp->subNode.atom = 'c';
C->subNode.hp->tp->subNode.hp->tp->tp = (Glist)malloc(sizeof(GLNode));

//原子d
C->subNode.hp->tp->subNode.hp->tp->tp->tag = 0;
C->subNode.hp->tp->subNode.hp->tp->tp->subNode.atom = 'd';
C->subNode.hp->tp->subNode.hp->tp->tp->tp = NULL;
return C;
}

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

广义表的复制详解（含C语言代码实现）

对于任意一个非空广义表来说，都是由两部分组成：表头和表尾。反之，

只要确定的一个广义表的表头和表尾，那么这个广义表就可以唯一确定下来。

复制一个广义表，也是不断的复制表头和表尾的过程。如果表头或者表尾同样是一个广义表，依旧复制其表头和表尾。

所以，复制广义表的过程，其实就是不断的递归，复制广义表中表头和表尾的过程。

递归的出口有两个：

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

还拿广义表 C 为例：

什么是广义表_广义表_05

图1 广义表 C 的结构示意图

代码实现：

#include <stdio.h>
#include <stdlib.h>

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

Glist creatGlist(Glist C){
//广义表C
C=(Glist)malloc(sizeof(GNode));
C->tag=1;
//表头原子‘a’
C->ptr.hp=(Glist)malloc(sizeof(GNode));
C->ptr.hp->tag=0;
C->ptr.hp->atom='a';
//表尾子表（b,c,d）,是一个整体
C->ptr.tp=(Glist)malloc(sizeof(GNode));
C->ptr.tp->tag=1;
C->ptr.tp->ptr.hp=(Glist)malloc(sizeof(GNode));
C->ptr.tp->ptr.tp=NULL;
//开始存放下一个数据元素（b,c,d）,表头为‘b’，表尾为（c,d）
C->ptr.tp->ptr.hp->tag=1;
C->ptr.tp->ptr.hp->ptr.hp=(Glist)malloc(sizeof(GNode));
C->ptr.tp->ptr.hp->ptr.hp->tag=0;
C->ptr.tp->ptr.hp->ptr.hp->atom='b';
C->ptr.tp->ptr.hp->ptr.tp=(Glist)malloc(sizeof(GNode));
//存放子表(c,d)，表头为c，表尾为d
C->ptr.tp->ptr.hp->ptr.tp->tag=1;
C->ptr.tp->ptr.hp->ptr.tp->ptr.hp=(Glist)malloc(sizeof(GNode));
C->ptr.tp->ptr.hp->ptr.tp->ptr.hp->tag=0;
C->ptr.tp->ptr.hp->ptr.tp->ptr.hp->atom='c';
C->ptr.tp->ptr.hp->ptr.tp->ptr.tp=(Glist)malloc(sizeof(GNode));
//存放表尾d
C->ptr.tp->ptr.hp->ptr.tp->ptr.tp->tag=1;
C->ptr.tp->ptr.hp->ptr.tp->ptr.tp->ptr.hp=(Glist)malloc(sizeof(GNode));
C->ptr.tp->ptr.hp->ptr.tp->ptr.tp->ptr.hp->tag=0;
C->ptr.tp->ptr.hp->ptr.tp->ptr.tp->ptr.hp->atom='d';
C->ptr.tp->ptr.hp->ptr.tp->ptr.tp->ptr.tp=NULL;
return C;
}
void copyGlist(Glist C, Glist *T){
//如果C为空表，那么复制表直接为空表
if (!C) {
*T=NULL;
}
else{
*T=(Glist)malloc(sizeof(GNode));//C不是空表，给T申请内存空间
//申请失败，程序停止
if (!*T) {
exit(0);
}
(*T)->tag=C->tag;//复制表C的tag值
//判断当前表元素是否为原子，如果是，直接复制
if (C->tag==0) {
(*T)->atom=C->atom;
}else{//运行到这，说明复制的是子表
copyGlist(C->ptr.hp, &((*T)->ptr.hp));//复制表头
copyGlist(C->ptr.tp, &((*T)->ptr.tp));//复制表尾
}
}
}
int main(int argc, const char * argv[]) {
Glist C=NULL;
C=creatGlist(C);
Glist T=NULL;
copyGlist(C,&T);
printf("%c",T->ptr.hp->atom);
return 0;
}

运行结果：

总结

在实现复制广义表的过程中，实现函数为：

void copyGlist(Glist C, Glist *T);

其中，Glist *T，等同于: struct GLNode* *T，此为二级指针，不是一级指针。在主函数中，调用此函数时，传入的是指针 T 的地址，而不是 T 。

这里使用的是地址传递，而不是值传递。如果在这里使用值传递，会导致广义表 T 丢失结点，复制失败。