【数据结构】栈、队列和数组

news2025/1/19 16:19:37

栈、队列和数组

  • 队列
  • 数组
    • 数组的顺序表示和实现
      • 顺序表中查找和修改数组元素
    • 矩阵的压缩存储
      • 特殊矩阵
      • 稀疏矩阵

在这里插入图片描述
初始化

#define MaxSize 50//栈中元素的最大个数
typedef char ElemType;

//数据结构
typedef struct{
    int top;//栈顶指针
    ElemType data[MaxSize];//存放栈中的元素
}SqStack;

//初始化栈,给top赋值为-1
void InitStack(SqStack *stack){
    stack->top = -1;
}

判断是否为空

//判断栈是否为空,空返回true,反之即返回false
bool StackEmpty(SqStack stack){
    if(stack.top==-1) return true;
    return false;
}

进栈

//进栈
bool Push(SqStack *stack,ElemType e){
    //判断是否满栈
    if(stack->top==MaxSize-1) return false;
    //指针先加1,再入栈
    stack->data[++stack->top]=e;
    return true;
}

出栈

//出栈
ElemType Pop(SqStack *stack){
    //判断是否为空栈
    if(stack->top==-1) return false;
    //先取值,再自减
    return stack->data[stack->top--];
}

读取栈顶元素

//读取栈顶元素
ElemType GetTop(SqStack stack){
    //判断是否为空栈
    if(stack.top==-1) return false;
    return stack.data[stack.top];
}

队列

在这里插入图片描述

初始化

#define MaxSize 5
typedef char ElemType;

typedef struct 
{
    ElemType data[MaxSize];
    int rear,front;
}SqQueue;

//初始化
void InitQueue(SqQueue *queue){
    queue->front = queue->rear=0;
}

判断空

//判断是否为空,即判断首尾指针是否相等
bool QueueEmpty(SqQueue queue){
    if(queue.front==queue.rear) return true;
    return false;
}

入队

//入队
bool EnQueue(SqQueue *queue,ElemType e){
    //判断是否是满队,即尾指针的下一个指向首指针
    if((queue->rear+1)%MaxSize==queue->front) return false;
    queue->data[queue->rear]=e;//赋值
    //尾指针+1取模
    queue->rear = (queue->rear+1)%MaxSize;
    return true;
}

出队

//出队
ElemType DeQueue(SqQueue *queue){
    //判断是否为空
    if(queue->front==queue->rear) return false;
    //先取值,首指针再+1取模
    ElemType e = queue->data[queue->front];
    queue->front++;
    return e;
}

数组

提到数组,大家首先会想到的是:很多编程语言中都提供有数组这种数据类型,比如 C/C++、Java、Go、C# 等。但本节我要讲解的不是作为数据类型的数组,而是数据结构中提供的一种叫数组的存储结构。

和线性存储结构相比,数组最大的不同是:它存储的数据可以包含多种“一对一”的逻辑关系。举个简单的例子:

在这里插入图片描述
上图中,{a1, a2, a3, a4}、{b1, b2, b3, b4}、{c1, c2, c3, c4}、{d1, d2, d3, d4} 中各自包含的元素具有“一对一”的逻辑关系,同时 a、b、c、d 这 4 个序列也具有“一对一”的逻辑关系。

这样存储不止一种“一对一”逻辑关系的数据,数据结构就推荐使用数组存储结构。


对于数组存储结构,我们可以这样理解它:数组是对线性表的扩展,是一种“特殊”的线性存储结构,用来存储具有多种“一对一”逻辑关系的数据。

实际场景中,存储具有 N 种“一对一”逻辑关系的数据,通常会建立 N 维数组:

  • 一维数组和其它线性存储结构很类似,用来存储只有一种“一对一”逻辑关系的数据:

在这里插入图片描述

  • 二维数组用来存储包含两种“一对一”逻辑关系的数据。二维数组可以看作是存储一维数组的一维数组
    在这里插入图片描述
  • n 维数组用来存储包含 n 种“一对一”逻辑关系的数据,可以看作是存储 n-1 维数组的一维数组;

数组存储结构还具有一些其它的特性,包括:

  • 无论数组的维度是多少,数组中的数据类型都必须一致;
  • 数组一旦建立,它的维度将不再改变;
  • 数组存储结构不会对内部的元素做插入和删除操作,常见的操作有 4 种,分别是初始化数组、销毁数组、取数组中的元素和修改数组中的元素。

数组的顺序表示和实现

数组可以是多维的,而顺序表只能是一维的线性空间。要想将 N 维的数组存储到顺序表中,可以采用以下两种方案:

  • 以列序为主(先列后行):按照行号从小到大的顺序,依次存储每一列的元素;
  • 以行序为主(先行后序):按照列号从小到大的顺序,依次存储每一行的元素。

多维数组中,最常用的是二维数组,接下里就以二维数组为例,讲解数组的顺序存储结构。
在这里插入图片描述
所示的二维数组按照“列序为主”的方案存储时,数组中的元素在顺序表中的存储状态如下图所示:
在这里插入图片描述
同样的道理,按照“行序为主”的方案存储数组时,各个元素在顺序表中的存储状态如图
在这里插入图片描述


顺序表中查找和修改数组元素

注意,只有在顺序表内查找到数组中的目标元素之后,才能对该元素执行读取和修改操作。

在 N 维数组中查找目标元素,需知道以下信息:

  • 数组的存储方式;
  • 数组在内存中存放的起始地址;
  • 目标元素在数组中的坐标。比如说,二维数组中是通过行标和列标来确定元素位置的;
  • 数组中元素的类型,即数组中单个数据元素所占内存的大小,通常用字母 L 表示;

根据存储方式的不同,查找目标元素的方式也不同。仍以二维数组为例,如果数组采用“行序为主”的存储方式,则在二维数组 anm 中查找 aij 位置的公式为:

LOC(i, j) = LOC(0, 0) + (i * m + j) * L;

其中,LOC(i, j) 为 aij 在内存中的地址,LOC(0, 0) 为二维数组在内存中存放的起始位置(也就是 a00 的位置)。

而如果采用以列存储的方式,在 anm 中查找 aij 的方式为:

LOC(i, j) = LOC(0, 0) + (j * n + i) * L;

根据以上两个公式,就可以在顺序表中找到目标元素,自然也就可以进行读取和修改操作了。


代码实现

#include<stdarg.h>
#include<malloc.h>
#include<stdio.h>
#include<stdlib.h> // atoi()
#include<io.h> // eof()
#include<math.h>

#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分配
} 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);
        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;
    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, ...) //在VC++中,...之前的形参不能是引用类型
{
    //依次为各维的下标值,若各下标合法,则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);
    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]
                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;
}

矩阵的压缩存储

特殊矩阵

这里所说的特殊矩阵,主要分为以下两类:

  • 含有大量相同数据元素的矩阵,比如对称矩阵;
  • 含有大量 0 元素的矩阵,比如稀疏矩阵、上(下)三角矩阵;

针对以上两类矩阵,数据结构的压缩存储思想是:矩阵中的相同数据元素(包括元素 0)只存储一个
在这里插入图片描述
数据元素沿主对角线对应相等,这类矩阵称为对称矩阵,矩阵中有两条对角线,对角线称为主对角线,另一条从左下角到右上角的对角线为副对角线。对称矩阵指的是各数据元素沿主对角线对称的矩阵。

对称矩阵的实现过程是,若存储下三角中的元素,只需将各元素所在的行标 i 和列标 j 代入下面的公式:
在这里插入图片描述
存储上三角的元素要将各元素的行标 i 和列标 j 代入另一个公式:

在这里插入图片描述
最终求得的 k 值即为该元素存储到数组中的位置(矩阵中元素的行标和列标都从 1 开始)。

例如,在数组 skr[6] 中存储图 1 中的对称矩阵,则矩阵的压缩存储状态如图所示(存储上三角和下三角的结果相同):
在这里插入图片描述
注意,以上两个公式既是用来存储矩阵中元素的,也用来从数组中提取矩阵相应位置的元素。例如,如果想从图中的数组提取矩阵中位于 (3,1) 处的元素,由于该元素位于下三角,需用下三角公式获取元素在数组中的位置,即:
在这里插入图片描述


稀疏矩阵

在这里插入图片描述
如果矩阵中分布有大量的元素 0,即非 0 元素非常少,这类矩阵称为稀疏矩阵。

压缩存储稀疏矩阵的方法是:只存储矩阵中的非 0 元素,与前面的存储方法不同,稀疏矩阵非 0 元素的存储需同时存储该元素所在矩阵中的行标和列标。

例如,存储上图中的稀疏矩阵,需存储以下信息:

  • (1,1,1):数据元素为 1,在矩阵中的位置为 (1,1);
  • (3,3,1):数据元素为 3,在矩阵中的位置为 (3,1);
  • (5,2,3):数据元素为 5,在矩阵中的位置为 (2,3);
  • 除此之外,还要存储矩阵的行数 3 和列数 3;

在这里插入图片描述
**若对其进行压缩存储,矩阵中各非 0 元素的存储状态如图 **
在这里插入图片描述
三元组的结构体

//三元组结构体
typedef struct {
    int i,j;//行标i,列标j
    int data;//元素值
}triple;

由于稀疏矩阵中非 0 元素有多个,因此需要建立 triple 数组存储各个元素的三元组。除此之外,考虑到还要存储矩阵的总行数和总列数,因此可以采用以下结构表示整个稀疏矩阵:

#define number 20
//矩阵的结构表示
typedef struct {
    triple data[number];//存储该矩阵中所有非0元素的三元组
    int mu, nu, tu;//mu和nu分别记录矩阵的行数和列数,tu记录矩阵中所有的非0元素的个数
}TSMatrix;
#include<stdio.h>
#define NUM 3
//存储三元组的结构体
typedef struct {
    int i, j;
    int data;
}triple;
//存储稀疏矩阵的结构体
typedef struct {
    triple data[NUM];
    int mu, nu, tu;
}TSMatrix;
//输出存储的稀疏矩阵
void display(TSMatrix M);
int main() {
    TSMatrix M;
    M.mu = 3;
    M.nu = 3;
    M.tu = 3;
    M.data[0].i = 1;
    M.data[0].j = 1;
    M.data[0].data = 1;
    M.data[1].i = 2;
    M.data[1].j = 3;
    M.data[1].data = 5;
    M.data[2].i = 3;
    M.data[2].j = 1;
    M.data[2].data = 3;
    display(M);
    return 0;
}
void display(TSMatrix M) {
    int i, j, k;
    for (i = 1; i <= M.mu; i++) {
        for (j = 1; j <= M.nu; j++) {
            int value = 0;
            for (k = 0; k < M.tu; k++) {
                if (i == M.data[k].i && j == M.data[k].j) {
                    printf("%d ", M.data[k].data);
                    value = 1;
                    break;
                }
            }
            if (value == 0)
                printf("0 ");
        }
        printf("\n");
    }
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/997364.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

MySQL无法查看系统默认字符集以及校验规则

show variables like character_set_database; show variables like collation_database;这个错误信息表示MySQL在尝试访问performance_schema.session_variables表时&#xff0c;发现该表不存在。这个问题可能是由于MySQL的版本升级导致的。解决这个问题的一种方法是运行mysql…

[管理与领导-81]:IT基层管理者 - 核心技能 - 高效执行力 - 6- 两大思维:服务思维、重点思维、高效与快速的区别?

目录 前言&#xff1a; 一、服务思维 二、重点思维 三、高效与快速的区别 补充&#xff1a;执行人才的表现 前言&#xff1a; 在某种程度上&#xff0c;高效与完美是相互制约的&#xff0c;要想高效&#xff0c;大多数时候&#xff0c;会牺牲一部分完美&#xff0c;而要达…

Pandas 掉包侠刷题实战--条件筛选

本博文内容为力扣刷题过程的记录&#xff0c;所有题目来源于力扣。 题目链接&#xff1a;https://leetcode.cn/studyplan/30-days-of-pandas/ 文章目录 准备工作1. isin(values) 和 ~2. df.drop_duplicates()3. df.sort_values()4. df.rename()5. pd.merge() 题目-条件筛选1. 大…

postgresql-窗口函数种类

postgresql-聚合窗口函数 聚合函数排名窗口函数案例1案例2 取值窗口函数环比增长率同比增长率 聚合函数 常用的聚合函数&#xff0c;例如 AVG、SUM、COUNT 等&#xff0c;也可以作为窗口函数使用 --计算移动平均值 select saledate, amount, avg(amount) over (order by sale…

Leetcode - 361周赛

一&#xff0c;2843. 统计对称整数的数目 这道题直接暴力&#xff0c;要注意的一点是这个数字必须是由 2 * N 位数字组成。 代码如下&#xff1a; class Solution {public int countSymmetricIntegers(int low, int high) {int ans 0;for(int ilow; i<high; i){if(i>1…

threejs的dat.gui辅助工具的使用

threejs的dat.gui辅助工具的使用 安装使用 安装 npm i dat.gui -S 使用 import dat from dat.gui const controlData {rotationSpeed: 0.01,color: #66ccff,wireframe: false } const gui new dat.GUI() const f gui.addFolder(配置) f.add(controlData, rotationSpeed, …

【Proteus仿真】【STM32单片机】血压心率血氧体温蓝牙

文章目录 一、功能简介二、软件设计三、实验现象联系作者 一、功能简介 系统运行后&#xff0c;LCD1604液晶显示心率、血氧、血压和体温&#xff0c;及其阈值&#xff1b;可通过K3键进入阈值设置模式&#xff0c;K1和K2加减调节&#xff0c;K4确定&#xff1b;当检测心率、血氧…

Java JUC 并发编程(笔记)

文章目录 再谈多线程并发与并行顺序执行并发执行并行执行 再谈锁机制重量级锁轻量级锁偏向锁锁消除和锁粗化 JMM内存模型Java内存模型重排序volatile关键字happens-before原则 多线程编程核心锁框架Lock和Condition接口可重入锁公平锁与非公平锁 读写锁锁降级和锁升级 队列同步…

ARMv7-A 那些事 - 2.通用寄存器与流水线

By: Ailson Jack Date: 2023.09.10 个人博客&#xff1a;http://www.only2fire.com/ 本文在我博客的地址是&#xff1a;http://www.only2fire.com/archives/154.html&#xff0c;排版更好&#xff0c;便于学习&#xff0c;也可以去我博客逛逛&#xff0c;兴许有你想要的内容呢。…

Visual Studio 2019 简单安装教程

思路 官方页面下载 – 安装Visual Studio Installer – 安装Visual Studio 2019 下载 打开页面&#xff1a;Visual Studio 2019 生成号和发布日期 | Microsoft Learn 点击需要的版本&#xff0c;跳转后会开始下载在线安装包&#xff0c;这里选择第一个Community版本 安装 …

SpringBoot【基础篇】

一、快速上手 按照要求&#xff0c;左侧选择web&#xff0c;然后在中间选择Spring Web即可&#xff0c;选完右侧就出现了新的内容项&#xff0c;这就表示勾选成功了 关注&#xff1a;此处选择的SpringBoot的版本使用默认的就可以了&#xff0c;需要说一点&#xff0c;SpringBo…

PatchMatchNet 学习笔记 译文 深度学习三维重建

9 PatchMatchNet CVPR-2021 patchmatchnet源码下载 PatchMatchNet 代码注释版 下载链接(注释非常详细,较源码结构有调整,使用起来更方便) PatchMatchNet-CVPR-2021(源码、原文+注释+译文+批注) 9.0 主要特点 金字塔,基于传统的PatchMatch算法,精度高,速度快 Pa…

Redis带你深入学习数据类型set

目录 1、set 2、set相关命令 2.1、添加元素 sadd 2.2、获取元素 smembers 2.3、判断元素是否存在 sismember 2.4、获取set中元素数量 scard 2.5、删除元素spop、srem 2.6、移动元素smove 2.7、集合中相关命令&#xff1a;sinter、sinterstore、sunion、sunionstore、s…

基于SSM的在线购物系统

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;采用JSP技术开发 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#x…

nrf52832 GPIO输入输出设置

LED_GPIO #define LED_START 17 #define LED_0 17 #define LED_1 18 #define LED_2 19 #define LED_3 20 #define LED_STOP 20设置位输出模式&#xff1a; nrf_gpio_cfg_output(LED_0); 输出高电平:nrf_gpio_pin_set(LED_0); 输…

sqli-labs关卡之一(两种做法)

目录 一、布尔盲注(bool注入) 二、时间盲注(sleep注入) 一、布尔盲注(bool注入) 页面没有报错和回显信息&#xff0c;只会返回正常或者不正常的信息&#xff0c;这时候就可以用布尔盲注 布尔盲注原理是先将你查询结果的第一个字符转换为ascii码&#xff0c;再与后面的数字比较…

[EROOR] SpringMVC之500 回调函数报错

首先&#xff0c;检查一下idea里面的报错的原因&#xff0c;我的是jdk的版本的问题。所以更换一下就可以了。

操作系统:四大特征(并发,共享,虚拟,异步)

1.并发 1.并发的定义 并发:指两个或多个事件在同一时间间隔内发生。 这些事件宏观上是同时发生的&#xff0c;但微观上是交替发生的。 值得注意的是&#xff0c;与并行&#xff08;指两个或多个事件在同一时刻同时发生&#xff09;区分开来。 2.操作系统的并发性 指计算机…

【微信读书】数据内容接口逆向调试01

需求爬取微信读书的某一本书的整本书的内容 增强需求&#xff0c;大批量爬取一批书籍内容 众所周知微信读书是一个很好用的app&#xff0c;他上面书籍的格式很好&#xff0c;质量很高。 本人充值了会员但是看完做完笔记每次还得去翻很不方便&#xff0c;于是想把书籍内容弄下…

【Unity基础】3.脚本控制物体运动天空盒

【Unity基础】3.脚本控制物体运动&天空盒 大家好&#xff0c;我是Lampard~~ 欢迎来到Unity基础系列博客&#xff0c;所学知识来自B站阿发老师~感谢 &#xff08;一&#xff09;搭建开发环境 &#xff08;1&#xff09;下载visual studio 在我们下载unity编译器的时候&…