3.栈和队列（基础数据结构）

最新推荐文章于 2024-09-15 11:34:55 发布
最新推荐文章于 2024-09-15 11:34:55 发布
阅读量85 收藏
点赞数
分类专栏： 基础数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mwt_442396446/article/details/116454792
版权

一.栈：一种先进后出，后进先出的数据结构

在这里插入图片描述
类比现实中的：箱子存放东西
栈分为顺序栈和链栈，本文件实现的是不定长的顺序栈
顺序栈的插入和删除都在尾部，因为入栈和出栈的时间复杂度为O（1）

顺序栈怎么设计

typedef struct Stack
{
	int* base; //用来malloc申请动态内存
	int stack_Size; //栈总体个数
	int top; //栈顶指针，当前栈存放的有效元素个数，指向下一个存放数据的位置
}Stack,*PStack;

在这里插入图片描述
顺序栈的具体代码实现： （一共有10中操作方法）

#include <stdio.h> 
#include <assert.h> 
#include <stdlib.h> 
#include "stack.h" 
void InitStack(PStack ps) //初始化
{ 
	assert(ps != NULL); 
	if(ps == NULL) return; 
	ps->base = (int *)malloc(sizeof(int) * INIT_SIZE); 
	assert(ps->base != NULL); 
	ps->top = 0; 
	ps->stack_Size = INIT_SIZE; 
}

bool Push(PStack ps, int val) //入栈操作（尾插）
{  
	assert(ps != NULL); 
	if(ps == NULL) return false; 
	if(IsFull(ps)) //判满 
	{ 
		//如果满了，扩容 Inc(ps); 
	} 
	ps->base[ps->top++] = val;//插入 
	return true; //返回值 
}

bool Get_top(PStack ps, int *rtval) //获取栈顶元素的值，但不删除 
{ 
	assert(ps != NULL); 
	if(ps == NULL) return false; 
	//-1 \0 //\0只用字符串认识他，别人根本不理它 '#'也不行 ‘#’== 35 
	if(IsEmpty(ps)) 
	{ 
		return false; 
	}
	*rtval = ps->base[ps->top-1]; 
	return true;
}

bool Pop(PStack ps, int *rtval) //获取栈顶元素的值，但删除，出栈操作（尾删） 
								//int Pop(PStack ps)    
{ 
	assert(ps != NULL && !IsEmpty(ps)); 
	if(ps == NULL || IsEmpty(ps)) return false; 
	获取值 //*rtval = ps->base[ps->top-1]; 有效个数-1 //ps->top--; //
	//返回值 
	*rtval = ps->base[--ps->top]; 
	return true; 
}

bool IsEmpty(PStack ps) //判空
{ 
	return ps->top == 0; 
}
 
bool IsFull(PStack ps) //判满
{ 
	return ps->top == ps->stack_Size; 
}

int Get_length(PStack ps) //获取有效元素个数 
{ 
	return ps->top; 
}
 
void Clear(PStack ps)   //清空
{
	ps->top = 0;
}
 
void Destroy(PStack ps) //销毁
{  
	assert(ps != NULL); 
	if(ps == NULL) return; 
	//释放malloc申请的动态内存 
	free(ps->base); //将指针赋值为NULL，防止出现野指针 
	ps->base = NULL; 
	ps->top = 0; 
	ps->stack_Size = 0; 
}
//扩容 
void Inc(PStack ps)//如果按2倍去扩容 1.5 
{  
	assert(ps != NULL); 
	if(ps == NULL) return;  
	ps->stack_Size *= 2; //给栈空间最大容量重新赋值 
	//从堆内申请更大的空间给我们 
	ps->base = (int *)realloc(ps->base, sizeof(int) * ps->stack_Size); 
	//realloc指在原有空间的基础上再多申请一些空间
}

链栈

我们实现的是带头结点的链栈
栈顶：入栈和出栈，让指向链表头部，时间复杂度则为O（1）（类比头插和头删）
链栈的示意图：
在这里插入图片描述
链栈怎么设计：

typedef struct LStack
{
	int data;//数据域
	LStack* next;//指针域
}LStack,*PLStack;

链栈的具体代码实现：

#include <stdio.h>   //(链栈）
#include <assert.h> 
#include <stdlib.h> 
//realloc 第一个：用的太少，容易出错  第二个点：有的编译器还需要
#include <alloc.h> 
#include "lstack.h" 

//带头节点的链栈
typedef int ElemType;
typedef struct LStack 
{
    ElemType data;
    LStack* next;
}LStack, * PLStack;

static PLStack Buy_Node(PLStack p, ElemType value)  //将新节点插入到p结点的后面
{
    PLStack new_node = (PLStack)malloc(sizeof(LStack));
    if (nullptr == new_node) return nullptr;
    new_node->next = p->next;
    new_node->data = value;
    return new_node;
}

//初始化
void InitStack(PLStack mylstack)
{
    assert(mylstack != nullptr);
    if(mylstack==nullptr) return;
    mylstack->next = nullptr;
}

//入栈
bool Push(PLStack mylstack, ElemType value)
{
    assert(mylstack != nullptr);
    PLStack new_node = Buy_Node(mylstack, value);
    if (nullptr == new_node) return false;
    mylstack->next = new_node;
    return true;
}

// // 获取栈顶元素但不删除
//ElemType Get_top(PStack mystack); 错误的返回值容易和存储的值冲突,
bool Get_top(PLStack mylstack, int* rtval)  //rtval是获取的值
{
    assert(mylstack != nullptr && rtval != nullptr);
    if (Empty(mylstack))
    {
        return false;
    }
    *rtval = mylstack->next->data;
    return true;
}
// 获取栈顶元素且删除//出栈
bool Pop(PLStack mylstack, int* rtval)
{
    assert(mylstack != nullptr && rtval != nullptr);
    if (Empty(mylstack))
    {
        return false;
    }
    *rtval = mylstack->next->data;

    PLStack p = mylstack->next;
    mylstack->next = p->next;
    free(p);
    p = nullptr;
    return true;
}

//判空
bool Empty(PLStack mylstack)
{
    return mylstack->next == nullptr;
}

//判满 链表栈不需要判满
//bool IsFull(PLStack mystack);

//清空
void Clear(PLStack mylstack)
{
    Destory(mylstack);
}
//销毁
void Destory(PLStack mylstack)
{
    assert(mylstack != nullptr);
    PLStack p = mylstack->next;
    while (p != nullptr)
    {
        mylstack->next = p->next;
        free(p);
        p = mylstack->next;
    }
}

//获取有效长度
int Get_Length(PLStack mylstack)
{
    assert(mylstack != nullptr);
    if (nullptr == mylstack)
    {
        return -1;
    }
    PLStack p = mylstack->next;
    int count = 0;
    while (p != nullptr)
    {
        count++;
        p = p->next;
    }
    return count;
}

二.队列

一种先进先出FIFO的数据结构，也是一种受到限制的顺序表
类比：现实中我们排队买饭，火车站买票
队列：只能一端进行入队，一端进行出队，入队的一端称作队尾，出队的一端称作队头，当队列中没有
数据元素的时候，称作空队
今天我要实现的是顺序队列：
队列存储方式分两种：顺序存储（顺序队列），一种链式存储（链队列）
我们实现的是定长的顺序队列：
在这里插入图片描述
在这里插入图片描述
顺序队列，我们要把它臆想成一个环形，这个做根本原因是：入队和出队的时间复杂度都为O（1）
在这里插入图片描述
做题时我们也遇到过这种处理成环形的题：
约瑟夫环，
在这里插入图片描述
在这里插入图片描述
队列成环后，怎么判断队空和队满？
队列判空条件为rear == front
队列判满条件为rear == front
那么我们怎么设计，让判空和判满不冲突：
第一种解决方案：申请一个变量当做计数器，存放当前队列的有效元素个数
第二种解决方案：浪费一个队尾空间不用，当做标记，当front == rear的时候，
我们认为队列为空，当队尾rear再走一步就遇到队头front的时候，我们认为队列为满
在这里插入图片描述
第三个难点：怎么获取队列有效元素个数？
在这里插入图片描述
顺序循环队列的设计：

#define MAXQSIZE 10 
typedef struct 
{
    int* base;
    //指向动态内存开辟的空间 
    int front;
    //头指针，指向队列第一个元素的下标 
    int rear;
    //为指针，当队列不空的时候，指向待插入元素存放空间的下标（队列尾部节点下一个 空间）
    //int maxsize；
    //当前申请顺序表最大空间个数 
}SqQueue,*PSqQueue;

顺序循环队列可执行的操作：

#pragma once 
//队列：一种先进先出的数据结构 
//为了使插入和删除时间复杂度都为O（1），所以我们将顺序队列想象成环形 
//这里比较难的有三个点： 
//1.为什么要想象成环形？ 插入和删除是用的最频繁的操作 
//2.怎么单独实现判空操作，和判满操作？ 
// 第一种解决方案：申请一个变量当做计数器，存放当前队列的有效元素个数 
// 第二种解决方案：浪费一个队尾空间不用，当做标记，当front == rear的时候， 
// 我们认为队列为空，当队尾rear再走一步就遇到队头front的时候，我们认为 队列为满 
//3.怎么获取队列有效元素个数？ (rear-front+MAXQSIZE)%MAXQSIZE 
#define MAXQSIZE 10 
typedef struct 
{ 
    int *base;
    //指向动态内存开辟的空间 
    int front;
    //头指针，指向队列第一个元素的下标 int rear;
    //为指针，当队列不空的时候，指向待插入元素存放空间的下标（队列尾部节点下一个 空间）
    //int maxsize；
    //当前申请顺序表最大空间个数 
}SqQueue,*PSqQueue; 
//队列可以实现的操作有哪些？ 
//增删改查 
//初始化 
void Init_Queue(PSqQueue sq); 
//入队操作 
bool Push(PSqQueue sq, int val); 
//获取队头第一个元素的值，但不删除 
bool Get_top(PSqQueue sq, int *rtval); 
//出队操作（获取队头第一个元素的值，并且删除） 
bool Pop(PSqQueue sq, int *rtval); 
//判空 
bool IsEmpty(PSqQueue sq);
//判满
bool IsFull(PSqQueue sq); 
//获取队列有效元素个数 
int Get_length(PSqQueue sq); 
//清空 
void Clear(PSqQueue sq); 
//销毁 
void Destroy(PSqQueue sq);

顺序循环队列具体代码实现：

#include <stdio.h> #include <assert.h> #include <stdlib.h> #include "queue.h" 
//初始化 
void Init_Queue(PSqQueue sq) 
{ 
    //断言
    assert(sq != NULL); 
    if(sq == NULL) return; 
    //对sq进行初始化 
    sq->base = (int *)malloc(sizeof(int) * MAXQSIZE); 
    assert(sq->base != NULL); 
    sq->front = 0; 
    sq->rear = 0; 
}
//入队操作 
bool Push(PSqQueue sq, int val) 
{ 
    //断言 
    assert(sq != NULL); 
    if(NULL == sq) return false; 
    if(IsFull(sq)) return false; 
    //插入 
    sq->base[sq->rear] = val; 
    //sq->rear++;
    //error 要变成环形处理 
    sq->rear = (sq->rear+1)%MAXQSIZE; 
    //返回值
    return true;
}
//获取队头第一个元素的值，但不删除 
bool Get_top(PSqQueue sq, int *rtval) 
{ 
    //断言 
    assert(sq != NULL &&rtval != NULL); 
    if(sq == NULL || rtval == NULL) return false; 
    if(IsEmpty(sq)) return false; 
    //把值通过输出参数带出去 
    *rtval = sq->base[sq->front]; 
    //返回值 return true; 
}
//出队操作（获取队头第一个元素的值，并且删除） 
bool Pop(PSqQueue sq, int *rtval) 
{ 
    //断言 
    assert(sq != NULL &&rtval != NULL); 
    if(sq == NULL || rtval == NULL) return false; 
    if(IsEmpty(sq)) return false; 
    //把值通过输出参数带出去 
    *rtval = sq->base[sq->front]; 
    //让头指针走一下
    //sq->front++;
    //error 处理成环形 
    sq->front = (sq->front+1)%MAXQSIZE; 
    //返回值 return true; 
}
//判空 
bool IsEmpty(PSqQueue sq) 
{ 
    assert(sq != NULL); 
    if(NULL == sq) return false; 
    return sq->front == sq->rear; 
}
//判满 
bool IsFull(PSqQueue sq) 
{ 
    assert(sq != NULL); 
    if(NULL == sq)
        return false; 
    //队尾指针再走一步，就遇到了队头，这时候我们认为队列满了 
    return (sq->rear+1)%MAXQSIZE == sq->front; 
}
//获取队列有效元素个数 
int Get_length(PSqQueue sq) 
{ 
    assert(sq != NULL);
    if(sq == NULL) return -1;
    //+MAXQSIZE的作用：防止出现负数
    //%MAXQSIZE的作用：防止多加 
    return (sq->rear - sq->front + MAXQSIZE)%MAXQSIZE;
}
//清空 
void Clear(PSqQueue sq) 
{ 
    assert(sq != NULL); 
    if(sq == NULL) return;
    sq->front = 0; 
    sq->rear = 0; 
}
//销毁 
void Destroy(PSqQueue sq)
{ 
    assert(sq != NULL);
    if(NULL == sq) return;
    free(sq->base); 
    sq->base = NULL;
    sq->front = 0;
    sq->rear = 0;
}
懒懒的小蜜蜂
关注
专栏目录
数据结构之—栈和队列
m0_58006481的博客
02-15 1329
栈和队列（基础队列+循环队列）；栈和队列相互转化、括号匹配问题、最小/大栈、队列中的最大值
数据结构——栈与队列
m0_57484470的博客
10-17 6472
数据结构栈与队列相关基础知识详解！！！
C语言数据结构：栈和队列
qq_42319810的博客
07-02 2051
define MaxSzie 10 //定义栈中元素的最大个数//静态数组存放栈中元素int top;//栈顶指针}SqStack;//初始化栈S.top = -1;//初始化栈顶指针SqStack S;//声明一个顺序栈（分配空间）.....//判空操作else//数据域//指针域}*LiStack;//栈类型定义队列（Queue）是只允许在一端进行插入，在另一端删除的线性表重要术语：队头、队尾、空队列。
数据结构 | 栈和队列
TTKunn的博客
09-15 1598
本文详细介绍了栈和队列的数据结构及其实现
《数据结构C语言版》——栈和队列详解(图文并茂)，从零开始的学习
青春无问西东 岁月自成芳华
04-20 4724
一文搞懂数据结构系列之栈和队列部分，从0基础到快速手敲数据结构，小白也能轻松看懂的宝典！
Java 数据结构：栈和队列
2301_78864183的博客
06-15 821
栈是一种遵循后进先出（LIFO, Last In First Out）原则的数据结构。想象一个叠放的盘子堆，你只能从顶部添加或移除盘子。栈的操作也类似，元素从栈顶添加（压栈）和移除（弹栈）。队列是一种遵循先进先出（FIFO, First In First Out）原则的数据结构。队列就像排队买票，先到的人先买票。队列的操作分别在两端进行：一端用于添加元素（入队），另一端用于移除元素（出队）。在Java中，我们可以利用Stack类、Queue接口及其各种实现类（如LinkedListArrayDeque。
【数据结构|C语言版】栈和队列
2302_80269373的博客
05-09 2134
各位小伙伴大家好！上次小编给大家讲解了数据结构中的重要基础：算法效率和复杂度分析，接下来我们讲解一下栈和队列！【知识框架】以上就是小编对栈和队列的讲解。如果觉得小编讲的还可以，还请一键三连。互三必回！持续更新中~！
数据结构之栈和队列
weixin_45699237的博客
02-19 2841
1、栈 1.1 概念 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈 顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据在栈顶。 ...
5.栈和队列
知其然，知其所以然
03-23 734
1.什么是栈和队列？（What） 2.为什么需要栈和队列？（Why） 3.如何学好栈和队列？（How）
数据结构试卷（一） 1.栈和队列的共同特点是( )。 A.只允许在端点处插入和删除元素
03-15
3. 在给定的数据结构选项中，队列、栈和线性表都是线性结构，因为它们的元素都可以形成一个单一的序列。而二叉树则是一种非线性结构，它的每个节点可以有零个、一个或两个子节点，形成了层次结构，不符合线性的前后...
数据结构3栈和队列.pdf
01-14
数据结构中的栈和队列是两种非常基础且重要的线性数据结构，它们在计算机科学中有着广泛的应用。栈，被称为“后进先出”（LIFO）的数据结构，因为元素的添加（入栈，Push）和移除（出栈，Pop）只能在栈顶进行。栈的...
JiSuanQi.rar_jisuanqi_栈和队列_计算器 数据结构
09-20
总的来说，这个项目提供了对数据结构栈和队列的实际应用案例，是学习和理解这些基础数据结构的好教材。通过阅读和分析源代码，可以深入了解如何在实际问题中运用这些抽象数据类型，并提高编程技能。同时，Visual C++...
NJUCM-数据结构课程3.实验三 栈和队列.zip
06-02
在本实验中，我们主要探讨了数据结构中的两种基本操作——栈和队列。栈是一种后进先出（LIFO）的数据结构，而队列则是一种先进先出（FIFO）的数据结构。这两种数据结构在计算机科学中有着广泛的应用，尤其是在算法...
数据结构中的栈和队列
01-05
PPT内容是数据结构中有关栈和队列的知识，非常适合正在学习数据结构基础的同学
职业教育中心 ASP教育中心网站程序网站源码，网站系统模板源码32.rar
09-23
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松copy复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（随意编程），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助 【资源内容】：项目具体内容可查看/点击本页面下方的*资源详情*，包含完整源码+工程文件+说明（若有）等。【若无VIP，此资源可私信获取】 【本人专注IT领域】：有任何使用问题欢迎随时与我联系，我会及时解答，第一时间为您提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【适合场景】：相关项目设计中，皆可应用在项目开发、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面中 可借鉴此优质项目实现复刻，也可基于此项目来扩展开发出更多功能 #注 1. 本资源仅用于开源学习和技术交流。不可商用等，一切后果由使用者承担 2. 部分字体及插图等来自网络，若是侵权请联系删除，本人不对所涉及的版权问题或内容负法律责任。收取的费用仅用于整理和收集资料耗费时间的酬劳 3. 积分资源不提供使用问题指导/解答
vue3+springboot农用车4S店管理系统[编号：CS_44067]源码数据库.zip
09-23
本文介绍了使用SpringBoot作为后端框架，Vue作为前端框架，MyBatis-Plus进行持久层开 。详细描述了系统测试的目的、功能测试案例，包括登录验证和用户管理，以及数据库设计。 前端：vue3 开发工具：IDEA 或者eclipse都支持 编程语言: java 框架：springboot/ssm都支持 jdk版本:jdk1.8以上均可 数据库: mysql 版本不限 数据库工具：Navicat/SQLyog都可以
基于Spring Boot 2.6.7的轻量级日志脚手架EasyLog设计源码
最新发布
09-23
该项目是Easy Log，一个基于Spring Boot 2.6.7开发的轻量级日志框架。它包含59个文件，其中48个Java源文件、2个Git忽略文件、1个LICENSE文件、1个Markdown文档、1个用于运行Maven的shell脚本、1个命令脚本、1个XML配置文件、1个工厂配置文件和1个YAML配置文件。Easy Log旨在简化日志记录流程，提供接口请求日志、错误日志，并支持通过编程方式记录操作日志，是业务开发中日志管理的得力助手。
全球恶嗪草酮行业总体规模、主要企业国内外市场占有率及排名（2024版）.docx
09-23
全球恶嗪草酮行业总体规模、主要企业国内外市场占有率及排名（2024版）.docx
栈和队列：数据结构基础与实现
理解和掌握栈和队列是学习数据结构和算法的基础，它们在各种算法和程序设计中发挥着核心作用，能够帮助我们高效地解决问题，提高程序性能。通过学习PPT课程，你可以深入理解这两种数据结构的定义、实现方法以及应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值