广义表总结
数据结构串、数组和广义表知识点总结
数据结构串、数组和广义表知识点总结
数据结构是计算机科学中研究数据如何组织、存储、管理和操作的学科。
三个常见的数据结构串、数组和广义表都是用于存储和操作数据的。
1. 串：
- 串是由0个或多个字符组成的有限序列。
它是一维数组的特例。
- 串的操作包括插入、删除、修改和查找等常见操作。
- 串可以通过数组、链表或动态分配的内存来实现。
2. 数组：
- 数组是一种线性数据结构，它由一组连续的内存空间组成，
存储相同类型的数据。
- 数组的操作包括插入、删除、修改和查找等常见操作。
- 数组的访问时间复杂度为O(1)，但插入和删除的时间复杂度
较高。
3. 广义表：
- 广义表是由若干元素组成的有序集合，每个元素可以是原子
或者是一个广义表。
- 广义表可以通过链表来实现，每个节点包含两个指针，一个
指向元素，一个指向下一个节点。
- 广义表的操作包括插入、删除、修改和查找等常见操作。
- 广义表可以表示任意层次的嵌套结构，具有灵活性和扩展性。
总结：
- 串、数组和广义表都是常见的数据结构，用于存储和操作数据。
- 串是字符的有限序列，可以通过数组或链表来实现。
- 数组是一维线性数据结构，存储相同类型的数据，具有常数时间复杂度的访问操作。
- 广义表是由元素组成的有序集合，可以通过链表来实现，能够表示任意层次的嵌套结构。
广义表的定义(精)
f(g)=
1 MAX{f(subg)}+1
int GLDepth(GLNode *g) /*求带头结点的广义表g的深度*/ { int max=0,dep; if (g->tag==0) return 0; /*为原子时返回0*/ g=g->val.sublist; /*g指向第一个元素*/ if (g==NULL) return 1; /*为空表时返回1*/ while (g!=NULL) /*遍历表中的每一个元素*/ { if (g->tag==1) /*元素为子表的情况*/ { dep=GLDepth(g); /*递归调用求出子表的深度 */ /*max为同一层所求过的子表中深度的最大值*/ if (dep>max) max=dep; } g=g->link; /*使g指向下一个元素*/ } return(max+1); /*返回表的深度*/ }
C a b c d
C a b c d
广义表的存储结构
广义表的情况 ：
g2 1
∧
g1
1
∧
∧
*
*
*
*
…
*
*
∧
第 1 个元素 （a）空表
第 2 个元素 （b）非空表
第 n 个元素
为原子的情况 ：
g3 0 a
∧
typedef struct lnode { int tag; union { ElemType data; /*结点类型标识*/
A()
A B e a b c d C A e
B(e)
D B a b c d C
C(a,(b,c,d))
广义表
一、基本概念 广义表是线性表的推广。线性表中的元素仅限于原子项 单 广义表是线性表的推广。线性表中的元素仅限于原子项(单 原子项 个数据元素)，即不可以再分，而广义表中的元素既可以是 个数据元素 ，即不可以再分，而广义表中的元素既可以是 原子项，也可以是子表(另一个线性表 另一个线性表)。 如果 如果a 原子项，也可以是子表 另一个线性表 。 (如果 i是单个数 据元素,则称 则称a 据元素 则称 i为广义表的原子 ) 1．广义表的定义 ． 广义表是n≥0个元素a …， 的有限序列， 广义表是 n≥0个元素a0， a1， …，an-1的有限序列， 其中每一 个元素 个 ai 或 者 是 原 子 ， 或 者 是 一 个 子 表 。 广 义 表 通 常 记 为 GL=(a0,a1,…,an-1)， 其中 为广义表的名字， 为广义表的 ， 其中GL为广义表的名字 ， n为广义表的 为广义表的名字 长度， 每一个a 为广义表的元素。但在习惯中， 长度， 每一个 i为广义表的元素。但在习惯中，一般用大写 字母表示广义表 小写字母表示原子。 表示广义表， 字母表示原子 字母表示广义表，小写字母表示原子。 称第一个元素a 为广义表GL的表头,其余部分 其余部分(a 称第一个元素 0为广义表 的表头 其余部分 1,...an-1)为GL 为 表尾,分别记作 的表尾 分别记作 head(GL)= a0 和 tail(GL)= (a1,...an-1)
tag=1
hp
tp
tag=0
atom
语言描述结点的类型如下： 用C语言描述结点的类型如下： 语言描述结点的类型如下 Typedef enum{Atom, LIST } Elemtag; typedef struct node { Elemtag tag; union{ AtomType atom; struct{struct node *hp,*tp;} ptr; }; }*GList;
第10讲广义表
1
1
4
一、广义表的类型定义
广义表的特性: 有次序性,有长度,有
深度,可共享,可递归。
D
A
B
C
f
a
E
e
b
c
d
11
广义表基本操作
1．GenListNode<ElemType> *First() const 初始条件：广义表已存在。 操作结果：返回广义表的第一个元素。 2．GenListNode<ElemType> *Next(GenListNode<ElemType> *elemPtr) const 初始条件：广义表已存在，elemPtr指向的广义表元素。 操作结果：返回elemPtr指向的广义表元素的后继 3．bool Empty() const 初始条件：广义表已存在。 操作结果：如广义表为空，则返回true，否则返回false
ref (a)头结点
nextLink
tag=ATOM(1)
atom (b)原子结点
nextLink
tag=LIST(2)
subLink (c)表结点
nextLink
15
A=()，B=(x, y, z)，C=(B, y, z)，D=(x,(y, z))，E=(x, E)
A B C D E 0 0 0 0 0 1 2 1 1 2 ∧ 1 2 1 2 x ∧ x 1 1 2 0 1 y y ∧ 1 y 1 z ∧ 1 1 z z ∧ ∧
本讲小结
重点： 1、广义表的基本概念 2、广义表的存储
难点： 1、广义表的递归算法
22
例1 求广义表的深度 P174 DepthHelp() 例2 复制广义表
P173 CopyHelp()
数据结构广义表
结点结构是无论什么结点都有三个域：
第一个域是结点类型标志tag； 第二个域是指向一个列表的指针（当tag=1时） 或一个原子（当tag=0时）； 第三个域是指向下一个结点的指针tp。
3 广义表的存储结构
形式描述为：
typedef enum{ ATOM, LIST }ElemTag typedef struct GLNode { //定义广义表结点 ElemTage tag; //公共部分，用以区分 原子结点和表结点 Unin{ //原子结点和表结点的联合部分 AtomType atom;//原子类型结点域， // AtomType由用户定义 struct GLNode *hp,; //表结点的表头指针域 }; struct GLNode *tp; //指向下一个结点的指针 }*Glist; //广义表类型
5． E=(a,E)
这是一个递归列表，其元素中有自己。
广义表也可以用图形表示，例如前述的广义表D和E可表示为：
广义表D
D
广义表E
E
C
A
B
a
e
a b c d
2 广义表的基本运算
广义表的基本运算 ⑴ 取表头 HEAD(LS)； ⑵ 取表尾 TAIL(LS)。
3 广义表的存储结构
广义表中的数据元素可以是单元素，或是广义表， •很难用顺序存储结构表示，常采用链式存储结构。 1.表头表尾链存储结构 有两类结点：表结点和单元素结点。
P 1 3 1 1
A=y((c,3),(D,2)) C=x((1,10),(2,6))
＾
1 2
A
z y 1 1 1 3
C
x 0 0 15 ＾
B
1 2
1 2
＾
第8章 广义表
为了简单起见,下面讨论的广义表不包括前面定 义的再入表和递归表,即只讨论一般的广义表。另 外,我们规定用小写字母表示原子,用大写字母表示 广义表的表名。例如： A=()
B=(e)
C=(a,(b,c,d))
D=(A,B,C)=((),(e),(a,(b,c,d)))
E=((a,(a,b),((a,b),c)))
广义表的两种基本情况 ：
g2 1
∧
g1
1
∧
∧
*
*
*
*
…
*
*
∧
第 1 个元素 （a）空表
第 2 个元素 （b）非空表
第 n 个元素
为原子的情况 ：
g3 0 a
∧
8.3
1. 求广义表的长度
广义表的运算
在广义表中,同一层次的每个结点是通过link域链
接起来的,所以可把它看做是由link域链接起来的单
链表。这样,求广义表的长度就是求单链表的长度,可
本章小结 本章的基本学习要点如下： (1)掌握广义表的定义。 (2)重点掌握广义表的链式存储结构。 (3)掌握广义表的基本运算,包括创建广义表、输出 广义表、求广义表的长度和深度。
(4)灵活运用广义表这种数据结构解决一些综合应 用问题。
练习
教材中p182习题1和2。
C
C a
a b
C 1
∧
c
d
b
c
d
0
a
1
∧
0
b
0
c
0
d
∧
广义表的存储结构
typedef struct lnode { int tag; union { ElemType data; /*结点类型标识*/
广义表的基本操作
广义表的基本操作1. 什么是广义表？广义表（Generalized List），又称为广义线性表、列表或链表，是一种扩展了线性表的数据结构。
与线性表只能存储单一类型的数据不同，广义表可以存储任意类型的数据，包括其他广义表。
广义表的存储结构通常采用链式存储。
2. 广义表的基本概念广义表由一系列的表头和表尾构成，表头可以是一个单一的元素，而表尾则是由更小的广义表组成。
广义表可以是空表，即没有任何元素。
例如，广义表L可以表示为： L = (a, b, c, (d, e), f)在该广义表中，a、b、c和f是表头元素，而(d, e)是表尾的广义表。
3. 广义表的基本操作3.1. 创建广义表广义表可以使用链表来实现。
通过遍历输入的数据，可以动态创建一个广义表。
class Node:def __init__(self, data):self.data = dataself.next = Nonedef create_list(data):head = Node(data[0])current = headfor i in range(1, len(data)):new_node = Node(data[i])current.next = new_nodecurrent = current.nextreturn head以上是一个简单的Python代码，用于创建广义表。
3.2. 获取广义表的表头和表尾广义表的表头可以通过简单的链表操作来获取，即获取链表的第一个节点的数据。
def get_head(L):return L.data广义表的表尾可以通过跳过第一个节点来获取。
如下所示：def get_tail(L):return L.next3.3. 判断广义表是否为空表通过判断广义表的表头是否为None，可以确定广义表是否为空表。
def is_empty(L):return L is None3.4. 获取广义表的长度获取广义表的长度可以通过遍历整个链表来计数。
数据结构广义表
数据结构广义表介绍广义表是一种扩展了线性表的数据结构，可以存储不仅仅是数据元素，还可以存储子表，从而形成多级结构。
在广义表中，元素可以是基本类型（如整数、字符等），也可以是广义表。
广义表由一组元素组成，每个元素可以是一个基本元素或者是一个子表。
广义表可以为空，称为空表。
广义表中的元素的个数称为广义表的长度。
广义表的表示广义表可以通过两种方式进行表示：括号表示和逗号表示。
1.括号表示：使用括号将广义表括起来，每个元素之间使用逗号分隔。
例如，(1,2,3)表示一个包含3个元素的广义表，分别为1、2和3。
2.逗号表示：用逗号将广义表的元素分隔开，如果元素是基本元素，则直接写在逗号之间，如果元素是子表，则将子表表示为广义表的形式。
例如，1,2,3表示一个包含3个元素的广义表，分别为1、2和3。
广义表的操作广义表支持多种操作，包括获取广义表的长度、判断广义表是否为空、获取广义表的头、获取广义表的尾、判断两个广义表是否相等、复制广义表等。
获取广义表的长度获取广义表的长度即求广义表中元素的个数。
可以使用递归的方式来实现这个操作。
如果广义表为空，则长度为0；否则，长度等于广义表头的长度加上广义表尾的长度。
判断广义表是否为空判断广义表是否为空即判断广义表中是否没有元素。
如果广义表长度为0，则为空；否则，不为空。
获取广义表的头获取广义表的头即获取广义表中第一个元素。
如果广义表为空，则没有头；否则，头等于广义表中的第一个元素。
获取广义表的尾获取广义表的尾即获取广义表中除了第一个元素以外的所有元素。
如果广义表为空，则没有尾；否则，尾等于广义表中除了第一个元素以外的所有元素所组成的广义表。
判断两个广义表是否相等判断两个广义表是否相等即判断两个广义表中的元素是否完全相同。
如果两个广义表都为空，则相等；如果两个广义表的长度不相等，则不相等；否则，判断广义表的头是否相等，如果相等则判断广义表的尾是否相等。
复制广义表复制广义表即创建一个与原广义表相同的新广义表。
数据结构数组与广义表知识点总结
数据结构数组与广义表知识点总结数组是一种线性数据结构，可以存储多个相同类型的元素。
它的特点是元素的大小固定，并且在内存中是连续存储的。
数组的访问方式是通过下标来访问，下标从0开始。
数组可以在编程中应用于各种情况，比如存储一组数字、一组字符串等。
广义表是一种扩展的线性数据结构，可以存储不同类型的元素。
它由元素和表构成，其中表可以是空表、原子或子表。
广义表可以递归定义，即子表可以包含更多的子表。
广义表的访问方式是通过递归来访问，可以对表的元素进行遍历和操作。
在数据结构中，数组和广义表都有自己的特点和用途，下面对它们的知识点进行总结：1.数组的特点及应用：-数组是一种线性数据结构，可以存储多个相同类型的元素。
-数组的内存分配是连续的，可以通过下标来访问元素。
-数组的大小固定，一旦定义后不能改变。
-数组的访问速度快，可以通过下标直接访问元素。
-数组适合用于存储一组相同类型的数据，比如一组数字、一组字符串等。
-数组的应用场景包括但不限于：排序算法、查找算法、图像处理、矩阵运算等。
2.数组的操作和常用算法：-初始化：可以直接赋值或使用循环初始化数组。
-访问元素：通过下标访问元素，下标从0开始。
-修改元素：直接通过下标修改元素的值。
-插入元素：需要移动插入位置之后的元素。
-删除元素：需要移动删除位置之后的元素。
-查找元素：可以使用线性查找或二分查找等算法。
-排序算法：比如冒泡排序、选择排序、插入排序等。
-数组还有一些常用的属性和方法，比如长度、最大值、最小值等。
3.广义表的特点及应用：-广义表是一种扩展的线性数据结构，可以存储不同类型的元素。
-广义表由元素和表构成，表可以是空表、原子或子表。
-广义表可以递归定义，即子表可以包含更多的子表。
-广义表的访问方式是通过递归遍历和操作。
-广义表适合存储一组不同类型的数据，比如存储学生信息、函数调用栈等。
-广义表的应用场景包括但不限于：函数式编程、树的表示、图的表示等。
广义表总结
5.4 稀疏矩阵
在特殊矩阵中，元素的分布呈现某种规律，故一定能找 到一种合适的方法，将它们进行压缩存放。但是，在实 际应用中，我们还经常会遇到一类矩阵：其矩阵阶数很 大，非零元个数较少，零元很多，但非零元的排列没有 一定规律，我们称这一类矩阵为稀疏矩阵。（非零元不 足5%的矩阵） 按照压缩存储的概念，要存放稀疏矩阵的元素，由于没 有某种规律，除存放非零元的值外，还必须存储适当的 辅助信息，才能迅速确定一个非零元是矩阵中的哪一个 位置上的元素。下面将介绍稀疏矩阵的几种存储方法及 一些算法的实现。
（b ）
（2）下三角矩阵 即矩阵的下三角部分元素是随机的，而上三角 部分元素全部相同（为某常数C）或全为0，具 体形式见下图（b）。
3．对角矩阵
若矩阵中所有非零元素都集中在以主对角线为中心的带 状区域中，区域外的值全为 0 ，则称为对角矩阵。常见 的有三对角矩阵、五对角矩阵、七对角矩阵等。 例如，下图为7×7的三对角矩阵（即有三条对角线上元 素非0）。
a00 a10 a20 ...
a11 a21 ... a22 ... ... ... ... an1n1
an10 a n11 a n12
一个下三角矩阵
下三角矩阵的压缩存储形式
思考：只存放上三角部分
以行序为主序存储上三角部分。
对于对称矩阵，除了用下三角存入外，还可用上三角形式 存放。这时数组a[0][0]存入sa[0]，a[0][1]存入sa[1]， a[0][2]存入sa[2]…，如下图。则sa[k]和a[i][j]之间的 对应关系为：
5.1 5.3
数组的基本概念 5.2 数组的存储结构
特殊矩阵及其压缩存储 5.4 稀疏矩阵 5.5 广义表 5.6 小结 5.7 练习
广义表知识点总结
广义表知识点总结一、广义表的概念和基本操作1.1 概念广义表是一种递归定义的数据结构，它可以包含原子元素和其他广义表，类似于树的结构。
广义表在计算机科学中广泛应用，常用于表示复杂的数据结构和递归算法。
1.2 基本操作广义表的基本操作包括创建、插入、删除、查找等，通过这些操作可以对广义表进行灵活的操作和管理。
在实际应用中，需要根据具体的需求对广义表进行不同的操作。
二、广义表的存储结构2.1 顺序存储结构顺序存储结构是将广义表中的元素按照顺序存储在内存中的一片连续空间中，可以通过下标访问元素，适合于对广义表进行随机访问的场景。
2.2 链式存储结构链式存储结构是通过指针将广义表中的元素连接起来，每个元素包含指向下一个元素的指针，适合于对广义表进行插入和删除操作的场景。
2.3 各种存储结构的比较在选择广义表的存储结构时，需要根据实际应用场景和需求来进行选择，顺序存储结构适合于对广义表进行随机访问，链式存储结构适合于对广义表进行插入和删除操作。
三、广义表的操作和应用3.1 创建广义表创建广义表可以通过递归的方式来实现，对于包含原子元素和子表的广义表，需要递归地创建子表并将它们链接起来。
3.2 插入和删除元素对于顺序存储结构的广义表，可以通过数组的插入和删除操作来实现元素的插入和删除；对于链式存储结构的广义表，可以通过修改指针来实现元素的插入和删除。
3.3 查找元素查找元素可以通过顺序遍历的方式来实现，对于包含子表的广义表，需要递归地进行遍历。
3.4 应用场景广义表在计算机科学中具有广泛的应用场景，包括对树的表示和操作、对图的表示和操作、对复杂数据结构的表示和操作等。
四、广义表的递归算法4.1 递归算法概念递归算法是指在解决问题的过程中，通过调用自身来处理子问题，直到子问题为空或者达到终止条件为止。
广义表的表示和操作通常涉及到递归算法。
4.2 广义表的递归遍历对于包含子表的广义表，需要通过递归算法来实现遍历操作，递归地对子表进行遍历，直到遍历到最底层的子表。
chapter5- 广义表
E(a,E(a,E（…）))
(3) 将广义表用树和图来描述
上面提到的广义表A、B、C的描述见图 5-11。
A B C
Hale Waihona Puke bcaA
A
B
b
c
b
c
a
(a) A=(b,c) (b) B=(a,A) (c) C=(A,B) 图 5-11 广义表用树或图来表示
一．取表头运算head
若广义表LS=(a1，a2，…，an)， 则Gethead(LS)=a1 。
第五章 广义表
5.1基本概念
广义表是第二章提到的线性表的推广。
线性表中的元素仅限于原子项，即不可
以再分，而广义表中的元素既可以是原
子项，也可以是子表(另一个线性表)。
1．广义表的定义
广义表是n≥0 个元素 a1 ， a2 ， … ， an 的有 限序列，其中每一个 ai或者是原子，或者 是 一 个 子 表 。 广 义 表 通 常 记 为 LS=(a1,a2,…,an) ，其中 LS 为广义表的名 字，n为广义表的长度， 每一个ai为广义 表的元素。但在习惯中，一般用大写字母 表示广义表，小写字母表示原子。
3．广义表的表示方法
(1) 用LS=(a1，a2，…，an)形式，其中 每一个ai为原子或广义表
例如： A=(b,c) B=(a,A) E=(a,E) 都是广义表。
（ 2 ）将广义表中所有子表写到原子形式， 并利用圆括号嵌套
例如，上面提到的广义表 A 、 B 、C 可以描 述为： A(b,c)
B(a,A(b,c))
2．广义表举例
(1) A=( ), A为空表，长度为0。
(2) B=(a,（b,c） ),B是长度为2的广义 表，第一项为原子，第二项为子表。
广义表的head和tail运算讲解
广义表的head和tail运算讲解一、引言广义表是一种常用的数据结构，它可以包含任意类型的元素，包括其他广义表。
广义表的h ea d运算和ta il运算是对广义表进行操作的两个基础运算，本文将对这两个运算进行详细讲解。
二、广义表的定义广义表是指可以包含各种元素的线性表，其中的元素可以是原子元素（如整数、字符等），也可以是广义表。
广义表由一系列元素组成，用括号表示，元素之间用逗号隔开。
三、h e a d运算h e ad运算用于获取广义表的第一个元素。
下面是h ea d运算的示意图：```广义表：(a,b,c,d,...)h e ad运算结果：a```四、t a i l运算t a il运算用于获取广义表除第一个元素外的剩余元素组成的广义表。
下面是t ai l运算的示意图：```广义表：(a,b,c,d,...)t a il运算结果：(b,c,d,...)```五、示例与应用假设有一个广义表`(1,(2,3),(4,(5,6)))`，我们可以通过h ea d运算和ta il运算来获取广义表中的元素。
-对该广义表进行hea d运算，将返回第一个元素1。
-对该广义表进行ta i l运算，将返回剩余元素组成的广义表`(2,3)`。
广义表的he ad和t ai l运算可以应用于各种场景。
例如，在处理嵌套列表时，可以通过递归地使用he ad和t ai l运算，来遍历并处理广义表中的所有元素。
以下是一个示例代码，演示了如何使用he a d和ta il运算来遍历广义表：```p yt ho n定义一个函数，用于遍历广义表d e ft ra ve rs e(ls t):i f ls t==[]:r e tu rnp r in t(ls t.he ad())t r av er se(l st.t ail())调用函数进行遍历l s t=Li st(1,L is t(2,Li st(3,L is t(4,L i st(5)))))t r av er se(l st)```通过以上示例，我们可以清晰地看到广义表的he ad和t ai l运算在遍历广义表时的作用。
12.广义表
数据结构
tag=1
hp
tp
tag=0
data
表结点
原子结点
头尾表示法结点结构
typedef enum {ATOM,LIST} ElemTag;//ATOM=0 ： 原 子 ； ElemTag;//ATOM=0 LIST=1 LIST=1：子表 typedef struct GLNode { tag;//标志域 标志域， ElemTag tag;//标志域，用于区分原子结点和表结点 //元素结点和表结点的联合部分 union { //元素结点和表结点的联合部分 atom; //atom是原子结点的值域 AtomType atom; //atom是原子结点的值域 *tp；}ptr; struct {struct GLNode *hp, *tp；}ptr; ptr. ptr. //ptr 是 表 结 点 的 指 针 域 ， ptr.hp 和 ptr.tp 分 别 指向表头和表尾 }; }*GList; //广义表类型 }*GList; //广义表类型
数据结构
广义表的结构相当灵活，在某种前提下，它可以兼容线性表、 广义表的结构相当灵活，在某种前提下，它可以兼容线性表、 数组、树和有向图等各种常用的数据结构。 数组、树和有向图等各种常用的数据结构。 当二维数组的每行（或每列）作为子表处理时， 当二维数组的每行（或每列）作为子表处理时，二维数组即为 一个广义表。 一个广义表。 (DEFUN HANOI(a b c n) (COND((=n1)(MOVE(COND((=n1)(MOVE-DISK a c)) (T (HANOI a c b (- n 1)) ((MOVE(MOVE-DISK a c) (HANOI b a c(- n 1)))) c(member(X,［X|Tail］ member(X,［X|Tail］). member(X,［Head|Tail］):-member(X,Tail). member(X,［Head|Tail］):?-member(a,［a,b,[c,d］]). member(a,［a,b,[c,d］
数组和广义表的学习心得
数组是用来存储同一种数据类型的数据的一种数据结构。
1、普通的一维数组是用来实现一些线性结构的好助手，例如我们使用的线性表的顺序存储，栈的顺序存储，队列的顺序存储，这里面都要-用到数组作为存储成部分。
2、经过扩展的二维数组，作用将更加明显，我们使用扩展的二维数组来存储矩阵。
而实际在工程的计算中矩阵的使用情况是十分普遍的。
我们将用到矩阵的加减法，这些必须都要投影到二维数组上进行计算，我们一般在使用二维数组时将会使用按行优先存储。
我们的教材中就会有非常明显的表现，在矩阵转置的算法中，我们就会使用到二维数组按行优先的存储，跳着找顺着存时，我们会将所有的列进行遍历，找到原来矩阵中某个元素的列值和现在这时for循环的列值是相等的。
将这个元素存储到相应现在这个三元组表中的位置。
即按列的顺序找，然后按顺序存入三元组中。
3、和数组相关的还有矩阵的压缩存储。
我们平时使用的数组中有些是非常特别的，例如有些数组中仅仅只有下三角部分是一些不同的元素，其余部分全是0.这个时候，我们从节省存储空间的角度考虑，我们可以使用矩阵的压缩存储。
我们使用一个一维数组来按行优先的顺序来存储这个矩阵，下三角矩阵是对称的，因此我们只在这个一维数组中存储下三角中的数据。
其余0的部分可以不存储，或者就是用一个存储单元来存储。
有以上所述，我们很自然的就想到将数组引申到矩阵的存储上来接着讨论。
存储特殊矩阵的时候，例如我们在存储下三角矩阵的时候，我们使用的是一维数组，将下三角按照行优先的顺序存储所有的数据。
在这个过程中，我们确定元素的下表是这样来的。
a ij的下标是这样的：k = i*(i+1)/2+j ,现在以k做下标来存储这个元素。
矩阵的存储。
特殊矩阵的存储我们可以使用一维数组来压缩存储。
普通矩阵的存储我猜想可以直接使用二维数组了。
但对稀疏矩阵的存储，我们应该使用三元组来存储。
我们直接记录非零元素所在的行标和列标和元素值。
很显然这将也会是一个一维数组，但是这个一维数组的数组元素不是普通的数据类型，他们是可以看成是一个个的单元格，这个单元格的特殊之处就是他们的成员有三个，行标，列标，元素值。
第五章 广义表
广义表是递归 递归定义的线性结构 线性结构， 递归 线性结构
LS = ( α1, α2, ⋅⋅⋅, αn ) 其中：αi 或为原子 或为广义表
例如: 例如 A = ( ) F = (d, (e)) D = ((a,(b,c)), F) C = (A, D, F) B = (a, B) = (a, (a, (a, ⋅⋅⋅ , ) ) )
1 0 a
1
∧
0 d
广义表的存储结构示意图 图5-14 广义表的存储结构示意图
在这种存储结构中有几种情况： 这种存储结构中有几种情况： 这种存储结构中有几种情况 (1)除空表的表头指针为空外，对任何非空列表，其 表头指针均指向一个表结点，且该结点中的hp域指示 列表表头(或为原子结点，或为表结点)，tp域指向列 表表尾(除非表尾为空，则指针为空，否则必为表结 点)； (2)容易分清列表中原子和子表所在层次。如在列表 D中，原子a和e在同一层次上，而b、c和d在同一层次 且比a和e低一层，B和C是同一层的子表； (3)最高层的表结点个数即为列表的长度。以上三个 特点在某种程度上给列表的操作带来方便。
表5-2
广 义 表
广义表及其示例 广义表及其示例
表长n 表深h 表深
D A e B a b c d C 0 1 2 3 ∞
A=() B=(e) C=(a,(b,c,d)) D=(A,B,C) E=(a,E)
0 1 2 3 2
广义表的图形表示 图 广义表的图形表示
例2：试用图形表示下列广义表. 试用图形表示下列广义表.
void hanoi (int n, char x, char y, char z) {//y为辅助塔 为辅助塔 if (n==1) move(x, 1, z); else { hanoi(n-1, x, z, y); move(x, n, z); hanoi(n-1, y, x, z); } }
零基础学数据结构 第8章 广义表
（5）CopyGList(&T,L)：复制广义表。由广义表L复制得到广义表T。复
制成功返回1；否则，返回0。
8.2 广义表的头尾链表表示与实现
8.2.1 广义表的头尾链表存储结构
因广义表中有两种元素：原子和子表，所以广义表的链表结点也分 为两种：原子结点和子表结点，其中，子表结点包含3个域：标志域、 指向表头的指针域和指向表尾的指针域。原子结点包含两个域：标志 域和值域。表结点和原子结点的存储结构如图8.1所示。
8.2 广义表的头尾链表表示与实现
（3）求广义表的长度。求广义表的长度只需要沿着表尾指针tp查找下去，统计子 表个数，直到tp为NULL为止。如果广义表是空表，则广义表的长度为0。否则， 将指针p指向结点的表尾指针，统计广义表的长度。 int GListLength(GList L) { int length=0; while(L) /*如果广义表非空，则将p指向表尾指针，统计表的长度*/ { L=L->ptr.tp;E就是一个递 Nhomakorabea的广义表。
任何一个非空广义表的表头可以是一个原子，也可以是一个广义表，而 表尾一定是一个广义表。例如： head(A)=()，tail（A）=()，head(C)=a,tail(C)=((b,c))， head(D)=A，tail(D)=(B,C) 其中，head(A)表示取广义表A的表头元素，tail(A)表示取广义表A的表 尾元素。
8.2 广义表的头尾链表表示与实现
求广义表的深度的算法实现如下。 int GListDepth(GList L) { int max,depth; GLNode *p; if(!L) /*如果广义表为空，则返回1*/ return 1; if(L->tag==ATOM) /*如果广义表是原子，则返回0*/ return 0; for(max=0,p=L;p;p=p->ptr.tp) /*逐层处理广义表*/ { depth=GListDepth(p->ptr.hp); if(max<depth) max=depth; } return max+1; }
第5章 数组和广义表总结
0603
2090
B5×4 = 0 8 0 0
0000
row col val
4000
0 12
0 44
1 06
1 28
2 19
3 03
现在，要通过A的 三元组表求其转置 矩阵B的三元组表。
row col val
0 16 0 33 1 02 1 29 2 18 4 04
16
三元组表的转置
方法1：设矩阵A是m行、n列、t个非0元素 从头到尾扫描A，将第0列的元素依次放入B（行号列号互换）; 从头到尾扫描A，将第1列的元素依次放入B（行号列号互换）; ．．．．．． 从头到尾扫描A，将第n-1列的元素依次放入B（行号列号互换）; 扫描A几趟？ 矩阵A的列数n
}tritype;
typedef struct { //三元组表
tritype data[MAXSIZE]; //三元组表存储空间
int mu, nu, tu;
//原矩阵的行数、列数、非0元素个数
}Tsmtype, *Tsmlink;
//三元组表说明符
14
三元组表
例 5.3 矩阵的转置。 求矩阵A的转置矩阵B，算法很简单：
ArrayInit(&A, n, d1, d2, ..., dn) ArrayDestroy(&A)
ArrayGet(A, i1, ..., in, &e)
ArrayAssign(&A, i1, ..., in, e) }ADT Array；
数组的基本操作一般不包括插入和删除
4
5.2 数组的存储结构
存储空间是在程序执行时动态分配的
n维数组A[u1][u2]…[un]
广义表应用的总结与展望
广义表应用的总结与展望
广义表（Generalized Table）是一种广泛应用于计算机科学和数据管理领域的数据结构。
它类似于关系型数据库中的表格，但比关系型数据库更加灵活，可以存储更复杂的数据结构，并且适用于各种类型的数据。
广义表在实际应用中有着广泛的用途和潜力。
以下是对广义表应用的总结和展望：
1. 数据存储和管理：广义表可以用于存储和管理各种类型的数据，包括文本、数字、图像、音频等。
它可以帮助组织和检索数据，实现高效的数据管理和访问。
2. 数据分析和挖掘：广义表提供了一种灵活的方式来组织和分析数据。
通过使用广义表，可以进行各种数据分析和挖掘任务，包括数据聚类、分类、关联等。
3. 数据交换和共享：广义表是一种通用的数据格式，可以被不同的系统和应用程序所认识和使用。
通过使用广义表，可以实现数据的跨系统和跨平台交换和共享。
4. 数据可视化：广义表可以被用于数据可视化，通过将数据转换成图表、图形、地图等形式，帮助用户更直观地理解和分析数据。
5. 网络爬虫和信息提取：广义表可以用于存储和处理从网络上抓取的数据。
它可以帮助爬虫程序将抓取的数据进行结构化和整理，方便后续的分析和应用。
6. 人工智能和机器学习：广义表可以作为机器学习和人工智能算法的输入和输出数据格式。
它可以帮助机器学习模型对复杂结构的数据进行处理和分析。
未来，随着数据的快速增长和应用需求的不断扩大，广义表的应用将会更加广泛和深入。
同时，随着技术的不断发展，广义表的性能和功能也将得到提升。
我们可以期待广义表在各个领域带来更多的创新和应用。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
广义表总结
1. 什么是广义表
广义表（Generalized List），又称为广义线性表，是一种可以存储多种数据类
型的数据结构。
它扩展了线性表的概念，线性表中的元素只能是基本数据类型，而广义表中的元素可以是基本数据类型，也可以是另一个广义表。
广义表是由原子节点和子表节点组成的，原子节点表示基本数据类型的元素，子表节点表示另一个广义表。
广义表可以用括号表示，括号内的元素可以是原子节点，也可以是子表节点。
例如，(1, (2, 3), (4, (5, 6)))表示一个包含三个元素的广义表，第一个元素
是一个原子节点1，第二个元素是一个包含两个原子节点2和3的子表节点，第
三个元素是一个包含两个原子节点4和一个包含两个原子节点5和6的子表节点。
2. 广义表的操作
广义表支持以下几种常见的操作：
2.1. 创建广义表
可以通过在括号内列举元素来创建广义表。
例如，(1, 2, 3)表示一个包含三
个原子节点的广义表，(1, (2, 3), (4, (5, 6)))表示一个包含三个元素的广义表，其中第二个元素是一个包含两个原子节点的子表节点。
2.2. 访问广义表的元素
可以通过索引来访问广义表中的元素。
索引从0开始，表示第一个元素。
对于
广义表(1, (2, 3), (4, (5, 6)))，索引0对应的元素是原子节点1，索引1对
应的元素是一个子表节点(2, 3)，索引2对应的元素是一个子表节点(4, (5, 6))。
2.3. 判断广义表是否为空
可以通过判断广义表的长度是否为0来判断广义表是否为空，如果长度为0，
则表示广义表为空。
2.4. 判断广义表的类型
可以通过判断广义表中的元素类型来判断广义表的类型。
如果元素类型都是原
子节点，则广义表的类型为原子表；如果元素类型都是子表节点，则广义表的类型为子表表；如果元素既有原子节点，又有子表节点，则广义表的类型为混合表。
2.5. 插入元素
可以在广义表的指定位置插入新的元素。
插入操作会改变广义表的结构。
2.6. 删除元素
可以删除广义表中的指定元素。
删除操作会改变广义表的结构。
2.7. 拼接广义表
可以将多个广义表拼接成一个新的广义表。
3. 广义表的应用
广义表在编程中有着广泛的应用。
它可以表示复杂的数据结构，例如树、图等。
在函数式编程中，广义表常用于表示递归数据结构，例如函数的参数列表、配置文件等。
广义表还可以用于实现表达式的解析和计算，例如在编译器设计中，可以将数
学表达式转化为对应的广义表，然后通过对广义表的操作来进行计算和优化。
此外，广义表还可以用于表示和操作XML、JSON等数据格式，通过将XML或JSON转化为广义表的形式，可以方便地操作和处理这些数据。
4. 广义表的优势与不足
广义表的优势在于能够灵活地存储和操作多种数据类型，使得数据的表示更加
灵活和具有扩展性。
广义表可以递归地定义复杂的数据结构，并且可以方便地进行操作和计算。
然而，广义表的操作相对复杂，需要对广义表的结构进行深度遍历和递归操作，相比于线性表的操作更加复杂和耗时。
在实际应用中，需要权衡广义表的灵活性和操作的方便性，选择合适的数据结构来存储和处理数据。
总的来说，广义表是一种重要的数据结构，具有广泛的应用领域，在实践中需
要根据具体的需求来选择合适的数据结构和算法。