数据结构与算法教程,数据结构C语言版教程!(第五部分、数组和广义表详解)六

 第五部分、数组和广义表详解

数组和广义表,都用于存储逻辑关系为“一对一”的数据。

数组存储结构,99% 的编程语言都包含的存储结构,用于存储不可再分的单一数据;而广义表不同,它还可以存储子广义表。

本章重点从矩阵的角度讨论二维数组的存储,同时讲解广义表的存储结构以及有关其广度和深度的算法实现。

十一、什么是广义表

前面讲过,数组即可以存储不可再分的数据元素(如数字 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 代表广义表的名称,a_{n} 表示广义表存储的数据。广义表中每个 a_{i}既可以代表单个元素,也可以代表另一个广义表。

1、广义表的原子和子表

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

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

2、广义表的表头和表尾

当广义表不是空表时,称第一个数据(原子或子表)为"表头",剩下的数据构成的新广义表为"表尾"

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

例如在广义表中 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 所示:

数据结构与算法教程,数据结构C语言版教程!(第五部分、数组和广义表详解)六_第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 所示:

数据结构与算法教程,数据结构C语言版教程!(第五部分、数组和广义表详解)六_第2张图片

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

}

1、广义表的另一种存储结构

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

数据结构与算法教程,数据结构C语言版教程!(第五部分、数组和广义表详解)六_第3张图片

图 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 所示:

数据结构与算法教程,数据结构C语言版教程!(第五部分、数组和广义表详解)六_第4张图片

图 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语言)