【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础

专栏:数据结构复习之路

复习完上面三章【线性表】【栈和队列】【串】,我们接着复习数组和广义表,这篇文章我写的非常详细且通俗易懂,看完保证会带给你不一样的收获。如果对你有帮助,看在我这么辛苦整理的份上,三连一下啦

目录

一、数组的定义

二、数组的顺序表示和实现

三、矩阵的压缩存储

3.1、特殊矩阵

3.1.1、对称矩阵

3.1.2、三角矩阵

3.1.3、对角矩阵(带状矩阵)

3.2、稀疏矩阵(超详细)

3.3、十字链表(稀疏矩阵的链式存储结构)

四、广义表的定义 

4.1、广义表的性质 

4.2、广义表的存储结构

4.1.1、链表表示(法1)

4.1.2、链表表示(法2) 

4.1.3、广义表的深度递归算法

结尾

Reference


一、数组的定义

数组和广义表可看成是一种特殊的线性表,其特殊在于: 表中的元素本身也是一种线性表,。内存连续。根据下标在O(1)时间读/写任何元素。

二维数组,多维数组,广义表、树、图都属于非线性结构。

数组特点:结构固定,定义后维数和维界不再改变。

数组基本操作:除了结构的初始化和销毁之外, 只有取元素和修改元素值的操作

二、数组的顺序表示和实现

一般都是采用顺序存储结构来表示数组,但数组可以是多维的,并且存储数据元素的内存单元地址是一维的,因此,在存储数组结构之前,需要解决将多维关系映射到一维关系的问题。

两种顺序存储方式:

  • 以行序为主序 (低下标优先)
  • 以列序为主序 (高下标优先)

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第1张图片 【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第2张图片

例题:

设数组 A[0…59, 0…69] 的基地址为 2048,每个元素占 2 个存储单元,若以列序为主序顺序存储,则元素 A[31, 57] 的存储地址为______。

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第3张图片


同理,对三维数组A[b1 ][b2 ][b3 ],可以看成b1个b2 × b3的二维数组, 若首元素的存储地址为LOC[0,0,0],则按行序为主序存放。

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第4张图片

则元素 a_{i00} 的存储地址为 LOC( i , 0 , 0) = LOC(0,0,0) + ( i × b2 ×  b3 ) * L

这是因为该元素之前有 i 个b2× b3的二维数组.

所以a_{ijk}的存储地址为 LOC( i , j , k) = LOC(0,0,0) + ( i ×  b2 × b3 + j × b3 + k) * L  

推广到一般情况,可得到 n 维数组数据元素存储位置的映像关系:

LOC(j1 ,j2 ,…,jn )=LOC(0,0,0)+(b2×…×bn×j1+ b3×…×bn×j2+…+bn× jn-1+ jn ) × L

代码实现:(选择性掌握,可能有些学校不怎么考察)

5.1数组的定义&5.2数组的顺序表示和实现-CSDN博客

看完这个博客的介绍,你也许就能理解如下代码的实现了:

这里我构造一个a[3][4][2]的三维数组,并给出完整可运行代码,自己参悟(有详细注释)。

#include
#include
#include
#include // atoi()
#include // eof()
#include
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW 3
#define UNDERFLOW 4
typedef int Status; //Status是函数的类型,其值是函数结果状态代码,如OK等
typedef int Boolean; //Boolean是布尔类型,其值是TRUE或FALSE
typedef int ElemType;
#define MAX_ARRAY_DIM 8 //假设数组维数的最大值为8
typedef struct
{
    ElemType* base; //数组元素基址,由InitArray分配
    int dim; //数组维数
    int* bounds; //数组维界基址,由InitArray分配
    int* constants; // 数组映象函数常量基址,由InitArray分配,即每变化一维的跨度,方便计算出base数组对应的下标
} Array;
Status InitArray(Array& A, int dim, ...)
{
    //若维数dim和各维长度合法,则构造相应的数组A,并返回OK
    int elemtotal = 1, i; // elemtotal是元素总值
    va_list ap;
    if (dim<1 || dim>MAX_ARRAY_DIM)
        return ERROR;
    A.dim = dim;
    A.bounds = (int*)malloc(dim * sizeof(int));
    if (!A.bounds)
        exit(OVERFLOW);
    va_start(ap, dim);
    for (i = 0; i < dim; ++i)
    {
        A.bounds[i] = va_arg(ap, int); //依次取出bound1 = 3, bound2 = 4, bound3 = 2
        if (A.bounds[i] < 0)
            return UNDERFLOW;
        elemtotal *= A.bounds[i];
    }
    va_end(ap);
    A.base = (ElemType*)malloc(elemtotal * sizeof(ElemType));
    if (!A.base)
        exit(OVERFLOW);
    A.constants = (int*)malloc(dim * sizeof(int));
    if (!A.constants)
        exit(OVERFLOW);
    A.constants[dim - 1] = 1; //一维跨度为1
    for (i = dim - 2; i >= 0; --i)
        A.constants[i] = A.bounds[i + 1] * A.constants[i + 1]; //计算其余维度跨度
    return OK;
}
Status DestroyArray(Array* A)
{
    //销毁数组A
    if ((*A).base)
    {
        free((*A).base);
        (*A).base = NULL;
    }
    else
        return ERROR;
    if ((*A).bounds)
    {
        free((*A).bounds);
        (*A).bounds = NULL;
    }
    else
        return ERROR;
    if ((*A).constants)
    {
        free((*A).constants);
        (*A).constants = NULL;
    }
    else
        return ERROR;
    return OK;
}
Status Locate(Array A, va_list ap, int* off) // Value()、Assign()调用此函数 */
{
    //若ap指示的各下标值合法,则求出该元素在A中的相对地址off

    int i, ind;
    *off = 0;
    for (i = 0; i < A.dim; i++)
    {
        ind = va_arg(ap, int);
        if (ind < 0 || ind >= A.bounds[i])
            return OVERFLOW;
        *off += A.constants[i] * ind;
    }
    return OK;
}
Status Value(ElemType* e, Array A, ...) 
{
    //依次为各维的下标值,若各下标合法,则e被赋值为A的相应的元素值
    va_list ap;
    Status result;
    int off;
    va_start(ap, A);
    if ((result = Locate(A, ap, &off)) == OVERFLOW) //调用Locate()
        return result;
    *e = *(A.base + off);
    return OK;
}
Status Assign(Array* A, ElemType e, ...)
{
    //依次为各维的下标值,若各下标合法,则将e的值赋给A的指定的元素
    va_list ap;
    Status result;
    int off;
    va_start(ap, e);
    if ((result = Locate(*A, ap, &off)) == OVERFLOW) //调用Locate()
        return result;
    *((*A).base + off) = e;
    return OK;
}
int main()
{
    Array A;
    int i, j, k, * p, dim = 3, bound1 = 3, bound2 = 4, bound3 = 2; //a[3][4][2]数组
    ElemType e, * p1;
    InitArray(A, dim, bound1, bound2, bound3); //构造3*4*2的3维数组A
    p = A.bounds;
    printf("A.bounds=");
    for (i = 0; i < dim; i++) //顺序输出A.bounds
        printf("%d ", *(p + i));
    p = A.constants;
    printf("\nA.constants=");
    for (i = 0; i < dim; i++) //顺序输出A.constants
        printf("%d ", *(p + i));
    printf("\n%d页%d行%d列矩阵元素如下:\n", bound1, bound2, bound3);
    printf("将 i*100+j*10+k赋值给A[i][j][k]:\n\n") ; //运行结果1 
//    printf("将(i * 4 * 2 + j * 2 + k) * 4赋值给A[i][j][k]:\n\n") ; //运行结果2 
    for (i = 0; i < bound1; i++)
    {
        for (j = 0; j < bound2; j++)
        {
            for (k = 0; k < bound3; k++)
            {
            	Assign(&A, i * 100 + j * 10 + k, i, j, k); // 将i*100+j*10+k赋值给A[i][j][k]   
//            	Assign(&A, (i * 4 * 2 + j * 2 + k) * 4, i, j, k); // 将(i * 4 * 2 + j * 2 + k) * 4赋值给A[i][j][k]
                Value(&e, A, i, j, k); //将A[i][j][k]的值赋给e
                printf("A[%d][%d][%d]=%2d ", i, j, k, e); //输出A[i][j][k]
            }
            printf("\n");
        }
        printf("\n");
    }
    p1 = A.base;
    printf("A.base=\n");
    for (i = 0; i < bound1 * bound2 * bound3; i++) //顺序输出A.base
    {
        printf("%4d", *(p1 + i));
        if (i % (bound2 * bound3) == bound2 * bound3 - 1)
            printf("\n");
    }
    DestroyArray(&A);
    return 0;
}

运行结果1:

A.bounds=3 4 2
A.constants=8 2 1 
3页4行2列矩阵元素如下:
将 i*100+j*10+k赋值给A[i][j][k]:

A[0][0][0]= 0 A[0][0][1]= 1
A[0][1][0]=10 A[0][1][1]=11
A[0][2][0]=20 A[0][2][1]=21
A[0][3][0]=30 A[0][3][1]=31

A[1][0][0]=100 A[1][0][1]=101
A[1][1][0]=110 A[1][1][1]=111
A[1][2][0]=120 A[1][2][1]=121
A[1][3][0]=130 A[1][3][1]=131

A[2][0][0]=200 A[2][0][1]=201
A[2][1][0]=210 A[2][1][1]=211
A[2][2][0]=220 A[2][2][1]=221
A[2][3][0]=230 A[2][3][1]=231

A.base=
   0   1  10  11  20  21  30  31
 100 101 110 111 120 121 130 131
 200 201 210 211 220 221 230 231

运行结果2:

A.bounds=3 4 2
A.constants=8 2 1
3页4行2列矩阵元素如下:
将(i * 4 * 2 + j * 2 + k) * 4赋值给A[i][j][k]:

A[0][0][0]= 0 A[0][0][1]= 4
A[0][1][0]= 8 A[0][1][1]=12
A[0][2][0]=16 A[0][2][1]=20
A[0][3][0]=24 A[0][3][1]=28

A[1][0][0]=32 A[1][0][1]=36
A[1][1][0]=40 A[1][1][1]=44
A[1][2][0]=48 A[1][2][1]=52
A[1][3][0]=56 A[1][3][1]=60

A[2][0][0]=64 A[2][0][1]=68
A[2][1][0]=72 A[2][1][1]=76
A[2][2][0]=80 A[2][2][1]=84
A[2][3][0]=88 A[2][3][1]=92

A.base=
   0   4   8  12  16  20  24  28
  32  36  40  44  48  52  56  60
  64  68  72  76  80  84  88  92

三、矩阵的压缩存储

矩阵定义:一个由 m×n 个元素排成的 m 行(横向) n 列(纵向)的表。

对于值相同的元素很多且呈某种规律分布、零元素多的矩阵,为了节省存储空间,可以对这类矩阵进行压缩存储。

矩阵的压缩存储:

  • 为多个相同的非零元素只分配一个存储空间
  • 对零元素不分配空间

 下面我们将会介绍特殊矩阵稀疏矩阵的压缩存储。

3.1、特殊矩阵

3.1.1、对称矩阵

在一个 n 阶方阵 A 中,若元素满足下述性质:a_{ij} = a_{ji} (1 ≤ i , j ≤ n ), 则称 A 为对称矩阵。

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第5张图片

对称矩阵上下三角中的元素数均 为: n(n + 1) / 2

因此可以行序为主序将元素存放在一 个 一维数组 sa[n(n+1)/2] 中:

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第6张图片

那么 a_{ij} 和 sa[k] 中,如何根据 i 和 j 确定其对应的数组下标 k 呢?

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第7张图片

解释:

【1】对于下三角形的行序存储:a_{ij} 前的 i -1 行有 1+ 2 +…+ (i -1)= i(i -1)/2 个元素(求和),在 第 i 行上有 j 个元素。

【2】对于上三角形的列序存储:a_{ij} 前的 j -1 列有 1+ 2 +…+ (i -1)= j(j -1)/2 个元素(求和),在 第 j 列上有 i 个元素。

⚠️注意:对于上三角的列序存储和下三角的行序存储,采用的分析方式是相同的。

  1. 对于上三角的行序存储的数组下标 k:\frac{(i - 1) * (2n -(i - 2))}{2} + j -i
  2. 对于下三角的列序存储的数组下标 k:\frac{(j - 1) * (2n -(j - 2))}{2} + i -j

因为a_{ij} = a_{ji},所以只要交换关系式中的 i 和 j 即可。

例题:

根据上面的公式,将 i = 6 , j = 7 代入得a67对于的下标k为:

[(6-1)* (2 * 8 - (6 - 2))]  / 2  +  (7 - 6) == 31

所以a67的地址为:1000 + 31 * 3 = 1093


当然这题的数据给的比较小,也可以不用公式:

这个元素在上三角部分中,是第6行中第2个元素,而这个元素的前面应该存储了31个元素(8+7+6+5+4+1=31),又由于每个矩阵元素占3个单元,所以矩阵元素a67的地址为1000+31×3=1093。

3.1.2、三角矩阵

以主对角线划分,三角矩阵有上(下)三角两种。 上(下)三角矩阵的下(上)三角(不含主对角线)中 的元素均为常数。在大多数情况下,三角矩阵常数为零。

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第8张图片

三角矩阵的存储:除了存储主对角线及上(下)三 角中的元素外,再加一个存储常数 c 的空间。

3.1.3、对角矩阵(带状矩阵)

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第9张图片

对角矩阵可按行优先顺序对角线的顺序。都可将其压缩存储到一维数组中,且也能找到每个非零元素和向量下标的对应关系。

当然对于按对角线存储我们也可以采用一个二维数组来存,这也许比用一维数组顺序存储方便一点:

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第10张图片

对于前者占用空间为:6 * 6 = 36,压缩后的空间占:5 * 6 = 30 ,虽然压缩的空间不是很多,但是当对角矩阵很大时,其压缩效果就比较显著了。

3.2、稀疏矩阵(超详细)

稀疏矩阵:设在 m×n 的矩阵中有 t 个非零元素。 令 \delta = t / (m × n) ,当 \delta ≤0.05 时称为稀疏矩阵。

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第11张图片

压缩存储原则:存各非零元的值、行列位置和矩阵的行列数。 

三元组 (i , j,a_{ij}) 惟一确定矩阵的 一个非零元,因此:

M 可以由 {(1,2,12), (1,3,9), (3,1,-3), (3,6,14), (4,3,24), (5,2,18), (6,1,15), (6,4,-7) } 和矩阵维数 (6, 7) 唯一确定。

⚠️通常,为了可靠描述,还会加一个总行数、总列数、非零元素总个数。

稀疏矩阵的压缩存储方法——顺序存储结构

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第12张图片

#define MAXSIZE 12500 //假设非零元个数的最大值

typedef struct { 
    int i, j; //该非零元的行列下标
    Elemtype e; 
}Triple;

typedef struct { 
    Triple data[MAXSIZE + 1]; 
    int mu, nu, tu; //矩阵的总行、总列数和总非零元个数
}TSMatrix;

扩展:已知一个稀疏矩阵的三元组表,求该矩阵转置矩阵的三元组表。

转置矩阵:一个 m×n 的矩阵 M,它的转置 T 是一个 n×m 的矩阵,且 T (i, j) = M[ j, i],1≤i≤n,1≤j≤m, 即 M 的行是 T 的列,M 的列是 T 的行。

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第13张图片

 法一:

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第14张图片

代码实现:

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第15张图片

Status TransposeSMatrix(TSMatrix M, TSMatrix &T) { 
    T.mu=M.nu; T.nu=M.mu; T.tu=M.tu; 
    int q = 1;
    if (T.tu) 
   { 
    for (int col = 1; col <= M.nu; ++ col) //nu是M的列
     {
    	 for (int p = 1; p <= M.tu; ++ p) { //tu是M对应的三元组非零元总数
    	 	if ( M.data[p].j == col ) {
    	 		T.data[q].i = M.data[p].j ; 
                T.data[q].j = M.data[p].i ; 
                T.data[q].e = M.data[p].e ;
                q++;
			 }
		 }
	 }
  }
  return OK; 
} // TransposeSMatrix 

时间复杂度:O(nu * tu) ,若 tu 与mu * nu 同数量级, 则为:O(mu* nu^{2} ) 


三元组的快速转置算法:

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第16张图片

上面那张图,是实现三元组快速转置前 ,必须需要求得的数据,下面就分别介绍它们的求法:

【1】num[col]的由来:

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第17张图片


【2】cpot[col] 的由来(借助num[col]):

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第18张图片


理解了上面两个数组的求解,下面就开始如何通过 cpot[col] 数组,准确找到转置矩阵T的三元组的每一行应该存哪一个非零元数:

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第19张图片

 【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第20张图片

 【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第21张图片


完整代码:

Status FastTransposeSMatrix( TSMatrix M, TSMatrix &T ,int num[] , int cpot[]) { 
// 采用三元组顺序表存储表示,求稀疏矩阵 M 的转置矩阵 T 
    T.mu = M.nu; T.nu = M.mu; T.tu = M.tu; 
    if (T.tu) { 
        for (int col=1; col<=M.nu; ++col) num[col] = 0; 
        for (int t = 1; t <= M.tu ; ++t) ++num[M.data[t].j]; // 求 M 中各列非零元的个数
        
        cpot[1] = 1;
        for (int col = 2; col <= M.nu ; ++col) cpot[col] = cpot[col -1] + num[col -1]; // 求 M 中各列的第一个非零元在 T.data 中的序号

        int col , q;
        for (int p = 1 ; p <= M.tu ; ++p) { // 开始求 M的转置 T对应的三元组
             col = M.data[p].j;
			 q = cpot[col]; 
             T.data[q].i = M.data[p].j; T.data[q].j = M.data[p].i; 
             T.data[q].e = M.data[p].e; 
			 cpot[col]++; 
            } 
   } 
   return OK;
} // FastTransposeSMatri

上面代码时间复杂度:O(nu + tu) ,若 tu 与 mu * nu 同数量级,则为:O(mu * nu)

优缺点:

三元组顺序表又称有序的双下标法

三元组顺序表的优点:非零元在表中按行序有序存储, 因此便于进行依行顺序处理的矩阵运算

三元组顺序表的缺点:不能随机存取。若按行号存取某一行中的非零元,则需从头开始进行查找。

3.3、十字链表(稀疏矩阵的链式存储结构)

正如三元组顺序表的缺点所在,我们可以用稀疏矩阵的链式存储结构来解决这个问题。

优点:它能够灵活地插入因运算而产生的新的非零元素, 删除因运算而产生的新的零元素,实现矩阵的运算。

在十字链表中,矩阵的每一个非零元素用一个结点表示,该结点除了(row,col,value)外,还有两个域:

  • right: 用于链接同一行中的下一个非零元素;
  • down:用以链接同一列中的下一个非零元素。

十字链表中结点的结构示意图:

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第22张图片 这里看两个稀疏矩阵的存储示意图,你大概就能明白他的大致结构了:

【1】【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第23张图片

【2】【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第24张图片

十字链表的结构类型说明如下:

typedef struct OLNode
{ 
   int i, j; // 非零元素的行和列下标
   ElemType e;
   struct OLNode * right, *down; // 非零元素所在行表、列表的后继链域
} OLNode; *OLink;

typedef struct
{ 
   OLink * rhead , *chead; //行、列链表的头指针向量基址,注意这里是指针数组(即OLNode结构的结点的指针的指针)
   int mu, nu, tu; //稀疏矩阵的行数、列数、非零元个数
} CrossList;

 这里的结构和上一章讲【数据结构复习之路】栈和队列(本站最全最详细讲解)& 严蔚敏版-CSDN博客

里面的队列的链式存储是非常相似的,只是这里的每一行、每一列都是可以看成一个链队列。

下面给出可运行的完整代码(三元组转十字链表),希望能帮助你理解:

#include
#include
typedef struct OLNode
{
    int i, j, e; //矩阵三元组i代表行 j代表列 e代表当前位置的数据
    struct OLNode* right, * down; //指针域 右指针 下指针
}OLNode, * OLink;
typedef struct
{
    OLink* rhead, * chead; //行和列链表头指针
    int mu, nu, tu;  //矩阵的行数,列数和非零元的个数
}CrossList;
void CreateMatrix_OL(CrossList* M);
void display(CrossList M);
int main()
{
    CrossList M;
    M.rhead = NULL;
    M.chead = NULL;
    CreateMatrix_OL(&M);
    printf("输出矩阵M:\n");
    display(M);
    return 0;
}
void CreateMatrix_OL(CrossList* M)
{
    int m, n, t;
    int num = 0;
    int i, j, e;
    OLNode* p = NULL, * q = NULL;
    printf("输入矩阵的行数、列数和非0元素个数:");
    scanf("%d%d%d", &m, &n, &t);
    (*M).mu = m;
    (*M).nu = n;
    (*M).tu = t;
    if (!((*M).rhead = (OLink*)malloc((m + 1) * sizeof(OLink))) || !((*M).chead = (OLink*)malloc((n + 1) * sizeof(OLink))))
    {
        printf("初始化矩阵失败");
        exit(0);
    }
   
    for (i = 0; i <= m; i++)
    {
        (*M).rhead[i] = NULL;
    }
    for (j = 0; j <= n; j++)
    {
        (*M).chead[j] = NULL;
    }
    while (num < t) {
        scanf("%d%d%d", &i, &j, &e);
        num++;
        if (!(p = (OLNode*)malloc(sizeof(OLNode))))
        {
            printf("初始化三元组失败");
            exit(0);
        }
        p->i = i;
        p->j = j;
        p->e = e;
        //链接到行的指定位置
        //如果第 i 行没有非 0 元素,或者第 i 行首个非 0 元素位于当前元素的右侧,直接将该元素放置到第 i 行的开头
        if (NULL == (*M).rhead[i] || (*M).rhead[i]->j > j)
        {
            p->right = (*M).rhead[i];
            (*M).rhead[i] = p;
        }
        else
        {
            //找到当前元素的位置
            for (q = (*M).rhead[i]; (q->right) && q->right->j < j; q = q->right);
            //将新非 0 元素插入 q 之后
            p->right = q->right;
            q->right = p;
        }
        //链接到列的指定位置
        //如果第 j 列没有非 0 元素,或者第 j 列首个非 0 元素位于当前元素的下方,直接将该元素放置到第 j 列的开头
        if (NULL == (*M).chead[j] || (*M).chead[j]->i > i)
        {
            p->down = (*M).chead[j];
            (*M).chead[j] = p;
        }
        else
        {
            //找到当前元素要插入的位置
            for (q = (*M).chead[j]; (q->down) && q->down->i < i; q = q->down);
            //将当前元素插入到 q 指针下方
            p->down = q->down;
            q->down = p;
        }
    }
}
void display(CrossList M) {
    int i,j;
    //一行一行的输出
    for (i = 1; i <= M.mu; i++) {
        //如果当前行没有非 0 元素,直接输出 0
        if (NULL == M.rhead[i]) {
            for (j = 1; j <= M.nu; j++) {
                printf("0 ");
            }
            putchar('\n');
        }
        else
        {
            int n = 1;
            OLink p = M.rhead[i];
            //依次输出每一列的元素
            while (n <= M.nu) {
                if (!p || (n < p->j) ) {
                    printf("0 ");
                }
                else
                {
                    printf("%d ", p->e);
                    p = p->right;
                }
                n++;
            }
            putchar('\n');
        } 
    }
}

输出结果:

输入矩阵的行数、列数和非0元素个数:3 4 4
1 1 3
1 4 5
2 2 -1
3 1 2
输出矩阵M:
3 0 0 5
0 -1 0 0
2 0 0 0

四、广义表的定义 

广义表(又称列表 Lists)是 n≥0个元素 a1 , a2 , …, an 的有限序列,其中每一个ai 或者是原子(单个元素),或者是一个子表

广义表通常记作: LS = (a1,a2,…,an )

其中: LS 为表名, n 为表的长度, 每一个 ai 为表的元素。 习惯上,一般用大写字母表示广义表,小写字母表示原子。

  • 表头:若 LS 非空 (n≥1 ),则其第一个元素 a1 就是表头。 记作 head(LS) = a1。
  • :表头可是原子,也可是子表。
  • 表尾:除表头之外的其它元素组成的表。 记作 tail(LS) = (a2 , ..., an )。
  • :表尾不是最后一个元素,而是一个子表。

【例题】 

  1. A=( ) :空表,长度为 0
  2. B=(( )) :长度为 1,表头、表尾均为 ( )
  3. C=(a, (b, c)) :长度为 2,由原子 a 和子表 (b, c) 构成,表头为 a ;表尾为 ((b, c))
  4. D=(x,y,z):长度为 3,每一项都是原子, 表头为 x ;表尾为 (y, z)
  5. E=(C, D):长度为 2,每一项都是子表。 表头为 C ;表尾为 (D)
  6. F=(a, F):长度为 2,第一项为原子,第二项为它本身(F),表头为 a ;表尾为 (F)

4.1、广义表的性质 

【1】 广义表中的数据元素有相对次序(一个直接前驱和一个直接后继【除了表头和表尾】)

【2】 广义表的长度定义为最外层所包含元素的个数; 如: C=(a, (b, c)) 是长度为 2 的广义表。

【3】 广义表的深度定义为该广义表展开后所含括号的重数。e.g: A = (b, c) 的深度为 1,B = (A, d) 的深度为 2, C = (f, B, h) 的深度为 3。

⚠️注意:“原子”的深度为 0 ; “空表”的深度为 1 。

【4】 广义表可以为其他广义表共享;如:广义表 B 就共享 表 A。在 B 中不必列出 A 的值,而是通过名称来引用。

【5】 广义表可以是递归的表。如:F=(a, F)=(a, (a, (a, …))) ,注意:递归表的深度是无穷值,长度是有限值。

【6】 广义表是多层次结构,广义表的元素可以是单元素, 也可以是子表,而子表的元素还可以是子表,…。 可以用形象地表示。

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第25张图片


广义表可看成是线性表的推广,线性表是广义表的特例

广义表的结构相当灵活,在某种前提下,它可以兼容线性表、数组、树和有向图等各种常用的数据结构。

当二维数组的每行(或每列)作为子表处理时,二维数组即为一个广义表

另外,树和有向图也可以用广义表来表示。 由于广义表不仅集中了线性表、数组、树和有向图等常 见数据结构的特点,而且可有效地利用存储空间,因此在计算机的许多应用领域都有成功使用广义表的实例

广义表基本运算:

取表头运算 GetHead 和 取表尾运算 GetTail

若广义表 LS=(a1 , a2 , …, an ), 则 GetHead(LS) = a1 , GetTail(LS) = (a2 , …, an )。

⚠️注意:取表头得到的结果可以是原子,也可以是一个子表。 取表尾得到的结果一定是一个子表。

e.g: D = ( E, F ) = ((a, (b, c)),F ) 

  • GetHead( D ) = E ,GetTail( D ) = ( F )
  • GetHead( E ) = a ,GetTail( E ) = ((b, c))
  • GetHead(((b, c))) = (b, c) ,GetTail(((b, c))) = ( )
  • GetHead((b, c)) = b ,GetTail((b, c)) = (c)
  • GetHead((c)) = c ,GetTail((c)) = ( )

4.2、广义表的存储结构

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

比如D = (a , ((b , c) , d) ) ,如果采用顺序存储,就需要一个三维数组,这是非常浪费存储空间的!

4.2.1、链表表示(法1)

法1也叫:头尾链表存储

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第26张图片

typedef struct GLNode {
    int tag;//标志域,用于区分元素结点和表结点

    union {  //元素结点和表结点的联合部分
        char atom;//atom是原子结点的值域
        struct {
            struct GLNode* hp, * tp;
        }ptr;//ptr是表结点的指针域,hp指向表头;tp指向表尾
    }un;
}GLNode, * Glist;

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

这里我用法1链表存储该广义表,并画出了图,你能看出哪些特点呢?

【1】

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第27张图片

【2】

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第28张图片

【3】 

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第29张图片

【4】 ​​​​​​​

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第30张图片

【总结】 

  1. 从图【2】可以看到,存储原子 a、b、c、d 时都是用子表包裹着表示的,因为原子 a 和子表 (b,c,d) 在广义表中同属一级,而原子 b、c、d 也同属一级。
  2. 就如A,除非A是一个空表,指针A的值为 NULL,否则指针A的指向的一定是 tag 值为 1 的子表结点。
  3. 采用首尾表示法容易分清列表中原子或子表所在的层次
  4. 最高层的表结点的个数即为广义表的长度

这里给出这种结构,求广义表长度的完整代码:

假设 C = (a , ( b , c , d ))

#include 
#include 
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

4.2.2、链表表示(法2) 

法2也叫:扩展线性链表存储(孩子兄弟链表)

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第31张图片

typedef struct GLNode {
    int tag;// 标志域,用于区分元素结点和表结点

    union {  // 元素结点和表结点的联合部分
        char atom;//原子结点的值域
        struct GLNode* hp;//表结点的表头指针
    }un;
    struct GLNode* tp;//这里的tp相当于链表的next指针,用于指向下一个数据元素
}GLNode, * GList;

这里我用法2链表存储该广义表,并画出了图,你能看出哪些特点呢?

【1】

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第32张图片

【2】 ​​​​​​​【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第33张图片

【3】 【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第34张图片

【4】 

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第35张图片

【总结】

  1. 无论 A 是否为空表,指针 A 指向的都是一个 tag 值为 1 的子表结点。当 A 为空表时,指针 A 所指结点的 hp 和 tp 指针都为 NULL。
  2. 最高层结点 tp 域必为 NULL
  3. 表达式中的左括号 “(  ” 对应存储表示中的 tag = 1 的结点。
  4. 就如【图2】,由于其最顶层(蓝色标注)表示的此广义表,而第二层(红色标注)表示的才是该广义表中包含的数据元素,因此可以通过计算第二层中包含的节点数量,才可求得广义表的长度。 

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第36张图片​选择一个自己更擅长的结构就行了,我更倾向于法1的存储结构。 

4.3、广义表的深度递归算法

思路: 

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

 基于法1的存储结构:

#include 
#include 
 
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;
}
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); //求以 pp -> ptr.hp为头指针的子表深度 
        if (dep>max) {
            max=dep;//每次找到表中遍历到深度最大的表,并用max记录
        }
    }
    //程序运行至此处,表明广义表不是空表,由于原子返回的是0,而实际长度是1,所以,此处要+1;
    return max+1;
}
int main(int argc, const char * argv[]) {
    Glist C=creatGlist(C);
    printf("广义表的深度为:%d",GlistDepth(C));
    return 0;
}

输出结果为:

广义表的深度为:2

结尾

最后,非常感谢大家的阅读。我接下来还会更新 数组和广义表 ,如果本文有错误或者不足的地方请在评论区(或者私信)留言,一定尽量满足大家,如果对大家有帮助,还望三连一下啦!

【数据结构复习之路】数组和广义表(严蔚敏版)万字详解&主打基础_第37张图片

我的个人博客,欢迎访问!

Reference

【1】严蔚敏、吴伟民:《数据结构(C语言版)》

【2】数据结构与算法基础(青岛大学-王卓)_哔哩哔哩_bilibili

【3】 数组的定义&5.2数组的顺序表示和实现

你可能感兴趣的:(数据结构复习之路,数据结构,数组和广义表,数据结构期末复习,严蔚敏版)