考研数据结构--数组与广义表

最新推荐文章于 2024-05-22 10:59:33 发布
最新推荐文章于 2024-05-22 10:59:33 发布
阅读量496 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 考研 算法 数组与广义表 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73856491/article/details/130492874
版权

数组与广义表

文章目录

数组

数组的基本概念

在这里插入图片描述

在这里插入图片描述

性质

  • 数组中的数据元素数目固定。一旦定义了一个数组，其数据元素数目不再有增减的变化。
  • 数组中的数据元素具有相同的数据类型。
  • 数组中的每个数据元素都和一组唯一的下标对应。
  • 数组是一种随机存储结构。可随机存取数组中的任意数据元素。

注意

  • 考研数据结构中的数组是作为一种数据结构讨论的。
  • 而编程语言中的数组是一种数据类型。
  • 前者可以借助后者来存储，像线性表的顺序存储结构即顺序表就是借助一维数组这种数据类型来存储的。但两者不能混淆。

数组的存储结构

数组特别适合采用顺序存储结构->将数组所有元素存储在一块地址连续的内存单元中。

数组不能采用链式存储结构吗？

答：数组可以采用链式存储结构，但是不常见。链式存储结构是用一组任意的存储单元存储线性表的数据元素，每个元素包括数据域和指针域。数组的数据域可以存储在链表的节点中，指针域可以指向下一个数组元素的位置。这样的链式存储结构称为静态链表，它是用一片连续的空间（数组，顺序）来存储实现的。

为什么数组一般采用顺序存储结构？

答：数组一般采用顺序存储结构，因为这样可以利用数组的随机访问特性，通过索引快速找到对应元素，而且相对节约存储空间。顺序存储结构就是把线性表中的所有元素按照某种逻辑顺序，依次存储到从指定位置开始的一块连续的存储空间。如果数组采用链式存储结构，就无法根据一个索引算出对应元素的地址，所以不能随机访问；而且由于每个元素必须存储指向前后元素位置的指针，会消耗相对更多的储存空间。

一维数组的存储结构

在这里插入图片描述

二维数组的存储结构

  • 以行序为主

在这里插入图片描述

在这里插入图片描述

若首元素是a00(此时尾元素是n-1),那么LOC(ai,j)=LOC(a00)+[ixn+j]xk

  • 以列序为主

在这里插入图片描述

在这里插入图片描述

特殊矩阵的压缩存储

特殊矩阵是指非零元素或零元素的分布有一定规律的矩阵。

为了节省存储空间，特别是当高阶矩阵的情况下，可以利用特殊矩阵的压缩存储来提高存储空间效率。

特殊矩阵的主要形式有:

(1)对称矩阵

(2)上三角矩阵/下三角矩阵

(3)对角矩阵

它们都是方阵，即行数和列数相同。

对称矩阵

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

上三角矩阵

在这里插入图片描述

在这里插入图片描述

下三角矩阵

在这里插入图片描述

对角矩阵

在这里插入图片描述

以三对角矩阵为例

在这里插入图片描述

在这里插入图片描述

稀疏矩阵

定义

一个阶数较大的矩阵中的非零元素个数s相对于矩阵元素的总个数t十分小时，即s<<t时，称该矩阵为稀疏矩阵。

因子&=s/t<=0.05

例如一个100×100的矩阵，若其中只有100个非零元素，就可称其为稀疏矩阵。

疏矩阵和特殊矩阵的不同点:

  • 特殊矩阵的特殊元素(值相同元素、常量元素)分布有规律。
  • 稀疏矩阵的特殊元素（非0元素）分布没有规律。

稀疏矩阵的三元组表示

在这里插入图片描述

在这里插入图片描述

稀疏矩阵的存储结构及其基本运算算法

在这里插入图片描述

定义

把稀疏矩阵的三元组线性表按顺序存储结构存储，则称为稀疏矩阵的三元组顺序表。

// 定义最大容量为100
#define MaxSize 100

// 定义稀疏矩阵的三元组结构体
typedef struct {
    int r; // 非零元素的行下标
    int c; // 非零元素的列下标
    int d; // 非零元素的值
} TupNode;

// 定义稀疏矩阵的结构体
typedef struct {
    int rows; // 矩阵的行数
    int cols; // 矩阵的列数
    int nums; // 非零元素的个数
    TupNode data[MaxSize]; // 三元组表
} TSMatrix;

在这里插入图片描述

约定: data域中表示的非零元素通常以行序为主序顺序排列，它是一种下标按行有序的存储结构。

这种有序存储结构可简化大多数矩阵运算算法。

存入三元组

在这里插入图片描述

// 将二维矩阵A转换为稀疏矩阵t
void CreatMat(TSMatrix &t, int A[M][N]) {
    t.rows = M; // 稀疏矩阵的行数为A的行数
    t.cols = N; // 稀疏矩阵的列数为A的列数
    t.nums = 0; // 稀疏矩阵的非零元素个数初始化为0
    for (int i = 0; i < M; ++i) { // 遍历A的每一行
        for (int j = 0; j < N; ++j) { // 遍历A的每一列
            if (A[i][j] != 0) { // 如果A[i][j]不为0
                t.data[t.nums].r = i; // 将其行下标存入稀疏矩阵的三元组
                t.data[t.nums].c = j; // 将其列下标存入稀疏矩阵的三元组
                t.data[t.nums].d = A[i][j]; // 将其值存入稀疏矩阵的三元组
                t.nums++; // 稀疏矩阵的非零元素个数加1
            }
        }
    }
}

三元组元素赋值

在这里插入图片描述

在这里插入图片描述

// 在稀疏矩阵t中插入元素x，行下标为i，列下标为j
bool Value(TSMatrix &t, int x, int i, int j) {
    int k = 0, k1; // 定义k和k1
    if (i >= t.rows || j >= t.cols) return false; // 如果i大于等于t的行数或j大于等于t的列数，返回false
    while (k < t.nums && i > t.data[k].r) k++; // 找到第一个行下标大于等于i的元素
    while (k < t.nums && i == t.data[k].r && j > t.data[k].c) k++; // 找到第一个行下标等于i且列下标大于等于j的元素
    if (i == t.data[k].r && j == t.data[k].c) { // 如果找到了行下标为i，列下标为j的元素
        t.data[k].d = x; // 将其值改为x
    } else { // 如果没有找到行下标为i，列下标为j的元素
        for (k1 = t.nums - 1; k1 >= k; k1--) { // 从后往前遍历，将第k个元素及其后面的元素后移一位
            t.data[k1 + 1].r = t.data[k1].r;
            t.data[k1 + 1].c = t.data[k1].c;
            t.data[k1 + 1].d = t.data[k1].d;
        }
        t.data[k].r = i; // 将新元素的行下标存入第k个元素的位置
        t.data[k].c = j; // 将新元素的列下标存入第k个元素的位置
        t.data[k].d = x; // 将新元素的值存入第k个元素的位置
        t.nums++; // 稀疏矩阵的非零元素个数加1
    }
    return true; // 返回true
}

取元素

在这里插入图片描述

// 在稀疏矩阵t中查找元素，行下标为i，列下标为j，将其值存入x中
bool Assign(TSMatrix t, int &x, int i, int j){
    int k = 0; // 定义k
    if (i >= t.rows || j >= t.cols) return false; // 如果i大于等于t的行数或j大于等于t的列数，返回false
    while (k < t.nums && i > t.data[k].r) k++; // 找到第一个行下标大于等于i的元素
    while (k < t.nums && i == t.data[k].r && j > t.data[k].c) k++; // 找到第一个行下标等于i且列下标大于等于j的元素
    if (i == t.data[k].r && j == t.data[k].c) { // 如果找到了行下标为i，列下标为j的元素
        x = t.data[k].d; // 将其值存入x中
    } else { // 如果没有找到行下标为i，列下标为j的元素
        x = 0; // 将x赋值为0
    }
    return true; // 返回true
}

输出三元组

// 输出稀疏矩阵t的三元组表
void DispMat(TSMatrix t){
    if (t.nums<=0)return; // 如果稀疏矩阵的非零元素个数为0，直接返回
    printf("\t%d\t%d\t%d\n",t.rows,t.cols,t.nums); // 输出稀疏矩阵的行数、列数和非零元素个数
    printf("-------------------------------\n"); // 输出分隔线
    for (int i = 0; i < t.nums; ++i) { // 遍历稀疏矩阵的每一个非零元素
        printf("\t%d\t%d\t%d\n",t.data[i].r,t.data[i].c,t.data[i].d); // 输出该元素的行下标、列下标和值
    }
}

十字链表法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

定义

// 定义常量M和N
#define M 3
#define N 2

// 定义常量Max，表示M和N中的最大值
#define Max ((M)>(N)?(M):(N))

// 定义结构体MatNode，表示稀疏矩阵的节点
typedef struct mtxn{
    int row; // 行下标
    int col; // 列下标
    struct mtxn *right,*down; // 指向右边和下面的节点
    union {
        int value; // 节点的值
        struct mtxn *link; // 指向另一个节点的指针
    } tag;
} MatNode;

广义表

定义

  • 广义表的定义：广义表是线性表的推广，它是由零个或多个原子或子表组成的有限序列。

  • 广义表可以用递归方法定义为：

    • 广义表是由原子和广义表组成的列表；
    • 原子是不可再分的数据单位；
    • 列表是由零个或多个原子或广义表组成的有限序列。

广义表通常用圆括号括起来表示，例如：(a,b,c)是一个由三个原子组成的广义表；(a,(b,c),d)是一个由两个原子和一个子表组成的广义表。

在这里插入图片描述

广义表的重要概念

在这里插入图片描述

广义表的存储结构

在这里插入图片描述

在这里插入图片描述

广义表的结点定义

typedef struct Inode{
    int tag; // 标记，用于区分是数据还是子表
    union {
        int data; // 数据域
        struct Inode *sublist; // 子表指针
    } val; // 共用体，用于存储数据或子表指针
    struct Inode *link; // 指向下一个节点的指针
} GLNode;

广义表算法设计方法

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

求广义表的长度

// 计算广义表的长度
int GLLength(GList g){
    if (g == NULL){ // 如果当前节点为空
        return 0; // 返回 0
    }
    return 1 + GLLength(g->link); // 递归计算下一个节点的长度
}

在这里插入图片描述

在这里插入图片描述

求广义表的深度

int GLDepth2(GList g){
    GList g1; // 用于遍历所有子表的指针
    int maxDep = 0; // 储存最大深度值
    int dep; // 储存当前深度值
    if (g->tag == 0) return 0; // 如果为原子结点，返回 0，即深度为 0
    g1 = g->val.sublist; // 指针 g1 指向 g 的子表
    if (g1 == NULL) return 1; // 如果子表为空，返回 1，即深度为 1
    while (g1 != NULL){ // 遍历所有子表
        if (g1->tag == 1){ // 如果该子表非空
            dep = GLDepth2(g1); // 递归计算深度值
            if (dep > maxDep) maxDep = dep; // 更新最大深度值
        }
        g1 = g1->link; // 指针 g1 移动到下一个节点
    }
    return maxDep+1; // 返回最大深度加上当前节点的深度（即 1）
}

在这里插入图片描述

在这里插入图片描述

输出广义表

在这里插入图片描述

// 定义一个函数，用于输出打印广义表
void PrintGL(GList g){
    if (g == NULL){ // 如果当前广义表为空表
        printf("#"); // 输出井号
    } else if (g->tag == 0){ // 如果当前元素是原子
        printf("%c", g->val.data); // 输出原子的值
    } else{ // 如果当前元素是子表
        printf("("); // 输出左括号
        PrintGL(g->val.sublist); // 递归打印子表
        printf(")"); // 输出右括号
    }
    if (g != NULL && g->link != NULL){ // 如果当前元素不是最后一个元素
        printf(","); // 输出逗号
        PrintGL(g->link); // 递归打印下一个元素
    }
}

// 定义一个函数，用于输出打印广义表
void DispGL(GList g){
    if (g != NULL){ // 如果当前节点不为空
        if (g->tag == 0){ // 如果当前节点是原子节点
            printf("%c", g->val.data); // 输出当前节点的值
        } else{ // 如果当前节点是子表节点
            printf("("); // 输出左括号
            if (g->val.sublist == NULL){ // 如果子表为空
                printf("#"); // 输出 #
            } else{ // 如果子表不为空
                DispGL(g->val.sublist); // 递归打印子表
            }
            printf(")"); // 输出右括号
        }
        if (g->link != NULL){ // 如果当前元素不是最后一个元素
            printf(","); // 输出逗号
            DispGL(g->link); // 递归打印下一个元素
        }
    }
}

在这里插入图片描述

建立广义表的链式存储结构

在这里插入图片描述

// 创建广义表
GList CreateGL(char *&s){
    GList g; // 定义一个广义表
    char ch = *s++; // 取出当前字符
    if (ch !='\0'){ // 如果当前字符不是结束符
        g = (GLNode *) malloc(sizeof(GLNode)); // 分配内存
        if (ch == '('){ // 如果当前字符是左括号
            g->tag = 1; // 标记为子表
            g->val.sublist = CreateGL(s); // 递归创建子表
        } else if (ch == '#'){ // 如果当前字符是井号
            g = NULL; // 标记为空表
        } else{ // 如果当前字符是其他字符
            g->tag = 0; // 标记为原子
            g->val.data = ch; // 存储原子的值
        }
    } else{ // 如果当前字符是结束符
        g = NULL; // 标记为空表
    }
    ch = *s++; // 取出下一个字符
    if (g != NULL){ // 如果当前广义表不为空表
        if (ch == ','){ // 如果下一个字符是逗号
            g->link = CreateGL(s); // 递归创建下一个元素
        } else{ // 如果下一个字符不是逗号
            g->link = NULL; // 标记为最后一个元素
        }
    }
    return g; // 返回创建好的广义表
}

// 创建广义表
GList CreateGL2(char *&s){
    GList g; // 定义一个指向广义表的指针
    char ch = *s++; // 获取字符串中的下一个字符
    switch (ch) {
        case '(':
            g = (GLNode *) malloc(sizeof(GLNode)); // 分配内存以存储广义表节点
            g->tag = 1; // 设置节点标记为1，表示这是一个子列表
            g->val.sublist = CreateGL(s); // 递归调用CreateGL函数来创建子列表
            break;
        case '#':
            g = NULL; // 如果字符是#，则表示这是一个空列表，将指针设置为NULL
            break;
        default:
            g = (GLNode *) malloc(sizeof(GLNode)); // 分配内存以存储广义表节点
            g->tag = 0; // 设置节点标记为0，表示这是一个原子
            g->val.data = ch; // 将字符转换为整数并将其存储在节点中
            break;
    }
    if (g == NULL || *s == '\0') { // 如果指针为NULL或字符串已经结束，则返回指针
        g->link = NULL;
        return g;
    }
    g->link = CreateGL(s); // 递归调用CreateGL函数来创建广义表的下一个节点
    return g;
}

在这里插入图片描述

在这里插入图片描述

图解

在这里插入图片描述

在这里插入图片描述

销毁广义表

void DestroyGL(GList g){
    if (g != NULL){ // 如果当前节点不为空
        if (g->tag == 1){ // 如果当前节点是子表节点
            DestroyGL(g->val.sublist); // 递归销毁子表
        }
        DestroyGL(g->link); // 递归销毁下一个元素
        free(g); // 释放当前节点的内存
    }
}

在这里插入图片描述

main函数测试

int main(){
    char *s = "(a,b,(c,d),e,(#))";
    char *s2 = "(a,b,(c,d),e)";
    GList g = CreateGL(s);
    GList g2 = CreateGL2(s2);
    PrintGL(g);
    PrintGL(g2);
    printf("销毁广义表");
    DestroyGL(g);
    return 0;
}

在这里插入图片描述

广义表例题–求原子个数

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

Maverick_曲流觞
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
考研-数据结构-殷人昆.zip
09-09
1.1 针对考研数据结构的代码书写规范以及C 与C 语言基础1 1.1.1 考研综合应用题中算法设计部分的代码书写规范1 1.1.2 考研中的C 与C 语言基础3 1.2 算法的时间复杂度与空间复杂度分析基础 12 1.2.1 考研中的算法时间...
数据结构1800题 - 经典版.zip
07-29
第5章 数组和广义表.doc 第5章 数组和广义表答案.doc 第6章 树和二叉树.doc 第6章 树和二叉树答案.doc 第7章 图.doc 第8章 动态存储管理.doc 第8章 动态存储管理答案.doc 第9章 集合.doc 第9章 集合答案....
计算机考研常考：广义表的定义以及数据结构，你都会了吗？
热门推荐
BoldFruit的博客
06-06 1万+
什么是广义表 广义表的定义 线性表 线性表指的是n≥0个元素a1, a2, a3…的有序数列，并且线性表的元素具有原子性，即结构上是不可分割的一个整体。 广义表(Generalized list) 而广义表则是线性表的一种扩展延伸。相对于线性表，广义表最大的特点在于其元素既可以是一个确定的类型，同时也可以是另一个有不定数量的元素组成的表（广义表）。 不难看出从广义表的定义是递归的。广义表是线性表的递归数据结构。 广义表的基本概念 广义表的表示 我们通常可以用 GL = (a1, a2, a3… an)来
考研复习 第四课：数组，广义表知识点
shitou123xsx的博客
07-27 592
一：数组： 数据结构特点： 结构中的元素本身可以是具有某种结构的数据，但属于同一数据类型 一维数组：可以看成一个线性表 二维数组：可以看成数据元素是一维数组 三维数组：可以看成数据元素是二维数组 数组元素的下标一般具有固定的上界和下界 数组一旦被定义，他的维数和维界就不在改变 数组仅有存取元素和修改元素的操作 数组的顺序表示： 因为...
数据结构-第四章-串、数组、广义表
qq_38738735的博客
12-16 689
KMP算法，next数组，特殊矩阵压缩，上下三角阵、三对角矩阵、对称阵，广义表，数据结构，408考研
数据结构-串 - 数组 - 广义表 - 矩阵-03
自学记录
11-18 364
123
数据结构：串、数组和广义表
qq_63042305的博客
10-17 1434
学习数据结构后总结了串，数组和广义表的基础内容,如存储结构，和相关的基本算法（如KMP算法与BF算法）
数据结构·串、数组和广义表
Yhan涵涵
05-27 236
串的定义：串是由零个或多个字符组成的序列，是的特殊线性表。串长：串中所包含的字符个数。空串：长度为零的串，它不包含任何字符。记作“∅”空格串：由一个或多个空格组成的串，其长度为串中空格字符的个数。它与空串∅是不同的概念。子串个数：2n+1串与线性表的区别：1.串的数据对象约束为字符集。2.线性表的基本操作中，大多以“单个元素”作为操作对象；而串的基本操作中，通常以“串的整体”作为操作对象。串与字符的区别："a"串，长度为1的串。（除了要存储字符‘a'，还要存储串长1）'a'字符a。
王道-习题-串 - 数组 - 广义表 - 矩阵-03
自学记录
11-28 96
123
六、考研数据结构笔记——数组与广义表
Mr_GYF的博客
12-01 1243
二维数组的行，列优先原则与一维数组之间的关系 对称矩阵，三角矩阵，三对角矩阵与一维数组下标k之间的转换公式， 广义表三个常考知识点
数据结构考研试题数组和广义表(有答案).pdf
07-14
数据结构考研试题数组和广义表(有答案).pdf
数据结构 数组和广义表.ppt
12-27
数据结构教程 有助于数据库的学习和考研的方向！
数据结构总结（自学、期末复习或考研备用）.pdf
01-16
第一章绪论、算法衡量指标、第二章线性表、顺序表、链表、第三章栈和队、栈、栈的应用举例、队列、循环队列、第四章串、串的模式匹配、第五章数组和广义表、稀疏矩阵的压缩存储方法:、广义表、第六章树和二叉树、...
考研数据结构笔记--数组、矩阵和广义表
BELL__Meng的博客
10-12 549
数组、矩阵和广义表一、数组1.1考研中常用的两种数组：1.2 二维数组的两种存储方式二、矩阵的压缩存储2.1 对称矩阵2.2 三角矩阵2.3 对角矩阵2.4 稀疏矩阵三、广义表3.1 概念3.2 三个重要结论3.3 广义表的存储结构 一、数组 1.1考研中常用的两种数组： 一维数组 (a0, a1, a2, ……, an-1) 二维数组 [(a0, 0, a0, 1, a0, 2, ……,...
数据结构_顺序队列基本操作的实现_代码
Hooray11的博客
05-16 211
【代码】数据结构_顺序队列基本操作的实现_代码。
数据结构_栈和队列学习
weixin_46571256的博客
05-19 429
简单易实现，空间固定，可能造成空间浪费或溢出。：检查栈顶指针是否为NULL。
P6【力扣144，94，145】【数据结构】【二叉树遍历】C++版
最新发布
qq_50891451的博客
05-22 352
从根节点开始遍历，并将根节点入栈，再遍历他的左子树，并依次入栈，直到该结点没有左子树。判断这个结点是否有右子树，如果没有，则将该结点弹出栈，并记录结点值。如果有则继续从他的右子树进行遍历，同时记录该结点的右子树是否遍历过，如果遍历过，则弹栈并记录结点值。时间复杂度：O（N）每个结点会遍历一次且只遍历一次。空间复杂度：O（N）栈至多会存放所有树节点。
王道考研数据结构与算法
10-11
王道考研数据结构与算法是一本非常经典的考研教材，适合准备考研的学生学习。它主要包含了数据结构和算法的基本知识、常见算法的思想和实现方法以及一些典型问题的解决思路。 在学习这本教材时，建议你按照章节顺序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值