数据结构个人笔记第14课广义表

最新推荐文章于 2024-05-21 22:55:36 发布

mcyuuji

最新推荐文章于 2024-05-21 22:55:36 发布

阅读量591

点赞数

分类专栏：数据结构笔记文章标签：数据结构链表

本文链接：https://blog.csdn.net/mcyuuji/article/details/121110700

版权

数据结构笔记专栏收录该内容

18 篇文章 4 订阅

订阅专栏

数据结构个人笔记第14课广义表

广义表

广义表

广义表，又称为列表，也是一种线性存储结构。同数组类似，广义表中既可以存储不可再分的元素，也可以存储广义表，记作：
LS = (a1,a2,…,an)
其中LS代表广义表的名称，an表示广义表存储的数据。广义表中每个ai既可以代表单个元素，也可以代表另一个广义表

广义表的原子和子表

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

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

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=(())是不一样的。前者是空表，而后者是包含一个子表的广义表，只不过这个子表是空表

广义表的表头和表尾

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

广义表的存储结构

方法一

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

使用顺序表实现广义表结构，不仅需要操作n组数组（例如{1,{2,{3,4}}}就需要使用三维数组存储），还会造成存储空间的浪费

使用链表存储广义表，首先需要确定链表中节点的结构。由于广义表中可同时存储原子和子表两种形式的数据，因此链表节点的结构也有两种。
广义表节点的两种类型

表示原子的节点由两部分构成，分别是tag标记位和原子的值，表示子表的节点由三部分构成，分别是tag标记位、hp指针和tp指针

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

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构成，用链表存储该广义表如图：

实现代码

Glist createGlist(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->tag = 1;
	C->subNode.ptr.tp->subNode.ptr.hp->subNode.ptr.hp->subNode.ptr.hp = (Glist) malloc(sizeof(Glist));
	C->subNode.ptr.tp->subNode.ptr.hp->subNode.ptr.hp->subNode.ptr.hp->tag = 0;
	C->subNode.ptr.tp->subNode.ptr.hp->subNode.ptr.hp->subNode.ptr.hp->subNode.atom='c';
	C->subNode.ptr.tp->subNode.ptr.hp->subNode.ptr.hp->subNode.ptr.tp=(Glist)malloc(sizeof(Glist));
	//存放子表d
	C->subNode.ptr.tp->subNode.ptr.hp->tag = 1;
	C->subNode.ptr.tp->subNode.ptr.hp->subNode.ptr.hp->subNode.ptr.hp->subNode.ptr.hp = (Glist)malloc(sizeof(Glist));
	C->subNode.ptr.tp->subNode.ptr.hp->subNode.ptr.hp->subNode.ptr.hp->subNode.ptr.hp->tag = 0;
	C->subNode.ptr.tp->subNode.ptr.hp->subNode.ptr.hp->subNode.ptr.hp->subNode.ptr.hp->subNode.atom = 'd';
	C->subNode.ptr.tp->subNode.ptr.hp->subNode.ptr.hp->subNode.ptr.hp->subNode.ptr.tp = NULL ;
	
	return C;
}

方法二

方法二
对应的结构体：

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

需要注意的是，无论采取以上哪一种节点结构存储广义表，都不要破坏广义表中各数据元素之间的并列关系。

实现代码

广义表2

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;
}

广义表的长度

广义表的长度，指的是广义表中所包含的数据元素的个数

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

广义表规定，空表{} 的长度为0

在编程实现广义表长度时，由于广义表的存储使用的是链表结构，且有以上两种方式

对于方法一来说，只需计算最顶层含有的节点数量，即可求得广义表的长度

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

实现代码

#include <stdio.h>
#include <stdlib.h>
typedef struct GLNode{
    int tag;//标志域
    union{
        char atom;//原子结点的值域
        struct{
            struct GLNode * hp,*tp;
        }ptr;//子表结点的指针域，hp指向表头；tp指向表尾
    };
}*Glist;
Glist creatGlist(Glist C){
    //广义表C
    C=(Glist)malloc(sizeof(Glist));
    C->tag=1;
    //表头原子‘a’
    C->ptr.hp=(Glist)malloc(sizeof(Glist));
    C->ptr.hp->tag=0;
    C->ptr.hp->atom='a';
    //表尾子表（b,c,d）,是一个整体
    C->ptr.tp=(Glist)malloc(sizeof(Glist));
    C->ptr.tp->tag=1;
    C->ptr.tp->ptr.hp=(Glist)malloc(sizeof(Glist));
    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(Glist));
    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(Glist));
    //存放子表(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(Glist));
    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(Glist));
    //存放表尾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(Glist));
    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;
}
int GlistLength(Glist C){
    int Number=0;
    Glist P=C;
    while(P){
        Number++;
        P=P->ptr.tp;
    }
    return Number;
}
int main(){
    Glist C = creatGlist(C);
    printf("广义表的长度为：%d",GlistLength(C));
    return 0;
}

广义表的深度

广义表的深度，可以通过观察该表中所包含括号的层数间接得到
在这里插入图片描述
此广义表从左往右有两层左括号（从右往左数也是如此），因此该广义表的深度为2

以上观察括号的方法需将广义表当做字符串来看待，并借助栈存储结构实现

编写程序计算广义表的深度，以第一种广义表为例，可以采用递归的方式：

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

其实，每次递归返回的值都是当前所在的子表的深度，原子默认深度为0，空表默认深度为1

代码实现

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->ptr.tp) {
        int dep=GlistDepth(pp->ptr.hp);
        if (dep>max) {
            max=dep;//每次找到表中遍历到深度最大的表，并用max记录
        }
    }
    //程序运行至此处，表明广义表不是空表，由于原子返回的是0，而实际长度是1，所以，此处要+1；
    return max+1;
}

广义表的复制和详解

对于任意一个非空广义表来说，都是由两部分组成：表头和表尾。反之，只要确定的一个广义表的表头和表尾，那么这个广义表就可以唯一确定下来

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

递归的出口有两个：

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

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

void copyGlist(Glist C,Glist *T);

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

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

实现代码

Glist 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));//复制表尾 
		}
	}
}

mcyuuji

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据结构个人笔记第14课广义表

数据结构个人笔记第14课广义表广义表广义表的原子和子表广义表的表头和表尾广义表广义表，又称为列表，也是一种线性存储结构。同数组类似，广义表中既可以存储不可再分的元素，也可以存储广义表，记作：LS = (a1,a2,…,an)其中LS代表广义表的名称，an表示广义表存储的数据。广义表中每个ai既可以代表单个元素，也可以代表另一个广义表广义表的原子和子表通常，广义表中存储的单个元素称为“原子”，而存储的广义表称为“子表”。以下是广义表存储数据的一些常用形式：A=()：A表示一个广义表，只不
复制链接

扫一扫