【数据结构】我家三岁表弟都明白的栈和队列，你不会不了解吧？

已于 2022-11-14 23:04:14 修改
阅读量1.2k 收藏 39
点赞数 69
分类专栏： 数据结构 文章标签： 栈 队列 数组实现 顺序存储 编程学习
于 2022-11-14 22:55:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47648037/article/details/127845283
版权

🧑‍💻作者： @情话0.0
📝专栏：《数据结构》
👦个人简介：一名双非编程菜鸟，在这里分享自己的编程学习笔记，欢迎大家的指正与点赞，谢谢！

在这里插入图片描述

栈和队列

一、栈

1.栈的基本概念

  栈是只允许在一端进行插入或删除操作的线性表。首先栈是一种线性表，但是对其限定该线性表只能在某一端进行插入或删除操作。
  栈顶：进行数据插入和删除操作的一端；
  栈底：不允许进行插入和删除的另一端；
  空栈：不含任何元素的空表。

栈中的元素遵守后进先出LIFO（Last In First Out）的原则。

  压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
  出栈：栈的删除操作叫做出栈。出数据也在栈顶。

在这里插入图片描述

2.栈的顺序存储（数组实现）

  栈是一种操作受限的线性表，可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
  采用顺序存储的栈称为顺序栈，它利用一组地址连续的存储单元（数组）存放自栈底到栈顶的数据元素，同时附设一个指针（top）指示当前栈顶元素的位置。

栈的顺序存储类型描述如下：

typedef int SDataType;

typedef struct Stack
{
	SDataType* array;
	int capacity; //栈的容量
	int top; //栈的元素个数
}Stack;

2.1 栈的初始化

void StackInit(Stack* ps)
{
	assert(ps);
	ps->array = (SDataType*)malloc(sizeof(SDataType)* 5);
	ps->capacity = 5;
	ps->top = 0;
}

栈顶指针：ps->top,初始化设置ps->top=0,指向栈顶元素的上层存储单元。

2.2 检查栈满

void CheckCapacity(Stack* ps)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		SDataType* arr = (SDataType*)realloc(ps->array, sizeof(SDataType)* (ps->capacity)*2);
		if (arr == NULL)
		{
			return;
		}
		ps->array = arr;
		ps->capacity *= 2;
	}
}

栈满条件为ps->top == ps->capacity，若空间已满，就进行2倍扩容。

2.3 入栈：尾插

void StackPush(Stack* ps, SDataType data)
{
	assert(ps);
	CheckCapacity(ps);
	ps->array[ps->top++] = data;
}

进栈操作：栈不满时，先将数据存储到top指针指向的存储空间，再将top指针加 1 ；栈满时先扩容，在插入元素。

2.4 出栈：尾删

void StackPop(Stack* ps)
{
	assert(!StackEmpty(ps));
	ps->top--;
}

出栈操作：先对栈进行断言判断是否为空，非空时只需将top指针减 1 即可，因为下一次进栈直接会将已经出栈的元素覆盖掉。

2.5 获取栈顶元素

SDataType StackTop(Stack* ps)
{
	assert(!StackEmpty(ps));
	return ps->array[ps->top - 1];
}

2.6 获取栈中有效元素的个数

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

由于使用数组来实现，所以栈顶指针的数据和有效元素个数相等。

2.7 检测栈是否为空

int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;
}

2.8 销毁栈

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->array);
	ps->capacity = 0;
	ps->top = 0;
	ps->array = NULL;
}

注意：这里的top指针指向栈顶元素的上层存储空间，所以进栈操作为ps->array[ps->top++] = data，出栈操作为ps->top--，。若栈顶指针初始化为ps->top=-1,即top指向栈顶元素，则入栈操作为ps->array[++ps->top]=data,出栈操作不变。栈空判断条件为ps->top==-1,栈满判断条件为++ps->top==ps->capacity。

3. 源代码

3.1 stack.h

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
typedef int SDataType;


typedef struct Stack
{
	SDataType* array;
	int capacity;
	int top;
}Stack;

void StackInit(Stack* ps);

// 入栈：尾插
void StackPush(Stack* ps, SDataType data);

// 出栈：尾删
void StackPop(Stack* ps);

// 获取栈顶元素
SDataType StackTop(Stack* ps);

// 获取栈中有效元素的个数
int StackSize(Stack* ps);

// 检测栈是否为空
int StackEmpty(Stack* ps);

// 销毁栈
void StackDestroy(Stack* ps);

3.2 stack.c

#include "stack.h"



void StackInit(Stack* ps)
{
	assert(ps);
	ps->array = (SDataType*)malloc(sizeof(SDataType)* 5);
	ps->capacity = 5;
	ps->top = 0;
}


void CheckCapacity(Stack* ps)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		SDataType* arr = (SDataType*)realloc(ps->array, sizeof(SDataType)* (ps->capacity)*2);
		if (arr == NULL)
		{
			return;
		}
		ps->array = arr;
		ps->capacity *= 2;
	}
}

// 入栈：尾插
void StackPush(Stack* ps, SDataType data)
{
	assert(ps);
	CheckCapacity(ps);
	ps->array[ps->top++] = data;

}

// 出栈：尾删
void StackPop(Stack* ps)
{
	assert(!StackEmpty(ps));
	ps->top--;
}

// 获取栈顶元素
SDataType StackTop(Stack* ps)
{
	assert(!StackEmpty(ps));
	return ps->array[ps->top - 1];
}

// 获取栈中有效元素的个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

// 检测栈是否为空
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;
}

// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->array);
	ps->capacity = 0;
	ps->top = 0;
	ps->array = NULL;
}

void Print(Stack* ps)
{
	assert(ps);
	int i = 0;
	while (i < ps->top)
	{
		printf("%d ", ps->array[i]);
		i++;
	}
	printf("\n");
}
void test()
{
	Stack ps;
	StackInit(&ps);
	StackPush(&ps, 0);
	StackPush(&ps, 1);
	StackPush(&ps, 2);
	StackPush(&ps, 3);
	StackPush(&ps, 4);
	StackPush(&ps, 5);
	Print(&ps);
	StackPop(&ps);
	Print(&ps);
	int ret = StackTop(&ps);
	printf("%d\n", ret);
	ret = StackSize(&ps);
	printf("%d\n", ret);
}

3.3 test.c

#include "stack.h"

int main()
{
	test();
	return 0;
}

二、队列

1.队列的基本概念

  队列也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队；删除元素称为出队。
  队头：允许删除的一端，又称队首；
  队尾：允许插入的一端；
  空队列：不含任何元素的空表。

  队列中的元素遵守后进先出FIFO（First In First Out）的原则。
在这里插入图片描述

2.队列的链式存储

  队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
  队列的链式表示称为链队列，它实际上是一个同时带有队头指针和队尾指针的单链表。头指针指向队头结点，尾指针指向队尾结点，即单链表的最后一个结点。
在这里插入图片描述

队列的链式存储类型描述如下：

typedef int QDataType;
typedef struct QNode //队列的每个节点（链表）
{
	int data;
	struct QNode* next;
}QNode;

typedef struct Queue //队列
{
	QNode* front; //队头指针
	QNode* rear; //队尾指针
	int size; //队列元素个数
}Queue;

2.1 队列初始化

void QueueInit(Queue* q)
{
	assert(q);
	q->front = NULL;
	q->rear = NULL;
	q->size = 0;
}

2.2 入队

void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newNode = (QNode*)malloc(sizeof(QNode)); //创建结点
	newNode->next = NULL;
	newNode->data = data;

	if (QueueEmpty(q)) //队列为空
	{
		q->front = newNode;
	}
	else //队列中已有元素
	{
		q->rear->next = newNode;
	}
	q->rear = newNode;
	q->size++;
}

2.3 出队

void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q)); //断言：队列为空
	QNode* delNode = q->front;
	if (q->front == q->rear) //队列中只有一个元素
	{
		q->front = q->rear = NULL;
	}
	else //队列有多个元素
	{
		q->front = delNode->next;
	}
	free(delNode);
	q->size--;
}

2.4 获取队头元素

QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->front->data;
}

2.5 获取队尾元素

QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->rear->data;
}

2.6 获取队列中有效元素的个数

int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}

2.7 检测队列是否为空

int QueueEmpty(Queue* q)
{
	assert(q);
	return q->rear == NULL;
}

2.8 销毁队列

void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->front;
	while (cur)
	{
		q->front = cur->next;
		free(cur);
		cur = q->front;
	}

	q->front = q->rear = NULL;
	q->size = 0;
}

3. 源代码

3.1 queue.h

#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <malloc.h>

typedef int QDataType;
typedef struct QNode
{
	int data;
	struct QNode* next;
}QNode;

typedef struct Queue
{
	QNode* front;
	QNode* rear;
	int size;
}Queue;

void QueueInit(Queue* q);
void QueuePush(Queue* q, QDataType data);
void QueuePop(Queue* q);
QDataType QueueFront(Queue* q);
QDataType QueueBack(Queue* q);
int QueueSize(Queue* q);
int QueueEmpty(Queue* q);
void QueueDestroy(Queue* q);
void QueueTest();

3.2 queue.c

#include "Queue.h"


void QueueInit(Queue* q)
{
	assert(q);
	q->front = NULL;
	q->rear = NULL;
	q->size = 0;
}
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	newNode->next = NULL;
	newNode->data = data;

	if (QueueEmpty(q))
	{
		q->front = newNode;
	}
	else
	{
		q->rear->next = newNode;
	}
	q->rear = newNode;
	q->size++;
}
void QueuePop(Queue* q)
{
	assert(q);
	if (QueueEmpty(q))
	{
		return;
	}
	QNode* delNode = q->front;
	if (q->front == q->rear)
	{
		q->front = q->rear = NULL;
	}
	else
	{
		q->front = delNode->next;
	}
	free(delNode);
	q->size--;
}
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->front->data;
}
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->rear->data;
}
int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->rear == NULL;
}
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->front;
	while (cur)
	{
		q->front = cur->next;
		free(cur);
		cur = q->front;
	}

	q->front = q->rear = NULL;
	q->size = 0;
}

void QueuePrint(Queue* q)
{
	assert(q);
	QNode* cur = q->front;
	while (cur)
	{
		printf("%d--->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

void QueueTest()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	QueuePush(&q, 6);
	QueuePrint(&q);
	QueuePop(&q);
	QueuePrint(&q);
	int ret = QueueFront(&q);
	printf("%d\n", ret);
	ret = QueueBack(&q);
	printf("%d\n", ret);
}

3.3 test.c

#include "Queue.h"

int main()
{
	QueueTest();
	return 0;
}

队列扩展：循环队列

  将循环队列臆造为一个环状的空间，即把存储队列元素的表从逻辑上视为一个环，称为循环队列。当队首指针q->front=maxszie-1后，再前进一个位置就自动到0。

初始化时：q->front = q->rear = 0;
队首指针进1：q->front = (q->front + 1) % MaxSize;
队尾指针进1；q->rear = (q->rear + 1) % MaxSize;
队列长度：(q->rear + MaxSize - q->front) % MaxSize;
出队入队时：指针都按顺时针方向进1;

从下图可以看出对空的条件是q->front = q->rear ，若入队元素的速度快于出队元素的速度，则尾指针很快就会赶上队首指针，可以看出队满时也有q->front = q->rear。为了区分队满还是队空，我们选择浪费一个空间不存储元素，约定以队头指针在队尾指针的下一个位置作为队满的标志。

队满条件：(q->rear + 1) % MaxSize == q->front;
队空条件：q->front = q->rear = 0;
队列中元素个数：(q->rear + MaxSize - q->front) % MaxSize。

在这里插入图片描述

总结

以上为对栈和队列的介绍，一定要注意最开始对其的初始化条件：比如栈的top指针到底指向哪里非常关键。相对来说栈与队列理解起来也比较轻松，主要是明白它们各自的属性特征。
  文章若有不足的地方还请大佬指正！！！

在这里插入图片描述

情话0.0
关注
专栏目录
2018清北学堂普及组冲刺班6连考总结反思
c_uizrp_dzjopkl的博客
10-01 1466
DAY 1 Problem 1 A(A.cpp/c/pas) 【题目描述】 给出一个n*m的网格，其中小明初始站在（x，y）这个位置，网格内无障碍，小明可以向上下左右四个方向一步走一格，问小明最少走几步可以走出网格。 【输入格式】 输入文件A .in 第一行四个整数n，m，x，y。 【输出格式】 输出文件A.out 一行一个整数表示答案。 【样例输入】 3 3 2 2 【样例输出】 2 【数据范围...
简单搜索引擎模型
春奇的专栏
07-16 8088
简单搜索引擎模型 A Simple Scratch of Search Engine 作者 史春奇， 搜索工程师， 中科院计算所毕业， chunqi.shi@hotmail.com 1， 需求迫切 2， 搜索引擎简单模型 3， 信息导航模型 4， 商家推广模型 5， 未来 本文是学习搜索引擎的涂鸦草稿， 高深读者请拐弯到：http://sewm.pku.edu.cn/IR-Guide.txt （北大搜索引擎小组--信息检索指南） 第一章 需求迫切 之前说过， 搜索引擎是互联网大爆
【数据结构】我家三岁表弟都明白的栈和队列，你不会不了解吧？(2)
2401_84166147的博客
05-06 644
出栈操作：先对栈进行断言判断是否为空，非空时只需将top指针减 1 即可，因为下一次进栈直接会将已经出栈的元素覆盖掉。
【数据结构】我家三岁表弟都明白的栈和队列，你不会不了解吧？(1)
2401_84592187的博客
05-15 938
if (q->front == q->rear) //队列中只有一个元素。typedef struct QNode //队列的每个节点（链表）QueueEmpty(q));typedef struct Queue //队列。// 获取栈中有效元素的个数。else //队列有多个元素。// 检测栈是否为空。
最全【数据结构】我家三岁表弟都明白的栈和队列，你不会不了解吧？，大数据开发岗
2401_84181501的博客
05-16 321
这里的top指针指向栈顶元素的上层存储空间，所以进栈操作为，出栈操作为ps->top--若栈顶指针初始化为ps->top=-1,即top指向栈顶元素，则入栈操作为,出栈操作不变。栈空判断条件为,栈满判断条件为。
大数据最全【数据结构】我家三岁表弟都明白的栈和队列，你不会不了解吧？，音视频时代你还不会NDK开发
2401_84181326的博客
05-07 895
采用顺序存储的栈称为顺序栈，它利用一组地址连续的存储单元（数组）存放自栈底到栈顶的数据元素，同时附设一个指针（top）指示当前栈顶元素的位置。队列也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈是一种操作受限的线性表，可以使用数组或者链表实现，相对而言数组的结构实现更优一些。：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。：进行数据插入和删除操作的一端；
2024年大数据最全【数据结构】我家三岁表弟都明白的栈和队列，你不会不了解吧？，阿里开发7年大牛
2401_84573219的博客
05-09 247
ps->top,初始化设置ps->top=0,指向栈顶元素的上层存储单元。
如何快速入门数据结构和算法
CSDN_430422的博客
07-10 201
有哪些常见的数据结构？基本操作是什么？常见的排序算法是如何实现的？各有什么优缺点？本文简要分享算法基础、常见的数据结构以及排序算法，给同学们带来一堂数据结构和算法的基础课。
别孤寡了，看看这篇 LinkedList 不香吗？
qq_39010254的博客
08-25 188
作者爱说话 Hello，我是 isysc 这是坚持原创的第8篇文章 每次写完文章都感觉，糟了糟了，爆文预定了，怎么办怎么办。等到正式发出去的时候，才知道，原来是想太多了。 每次写文章的选题都是一件很纠结的事，就比如我从下午 5.30 坐在电脑前想选题到了 6 点，终于决定好了，还是先去吃饭吧。 回来的路上终于有了灵感，写一些集合相关的源码？ Got it 背景引入 虽然今天阳光明媚，但是林布丁的心里却下起了雨，不是因为女朋友的傲娇，而是今天上午面试官说的 “ArrayList和...
我的 Java 后端面试日记！
HollisChuang's Blog
11-20 1255
本文经授权转载自微信公众号：石杉的架构笔记，作者：Pz背景在老东家五年了，总共工作整七年，经历两家公司。2019-10-31日离职。公司规模较小，项目压力不大，非985/...
这帖子,程序员的痛心疾首,我明臣哭了.
ming901016的专栏
08-15 3745
<br />一个初中生到程序员的辛酸经历出自：一个初中生到程序员的辛酸经历<br /><br />前言：我将写下一个穷苦家庭的农村孩子的经历。我念书不多，文笔不好，基本上是流水式的叙述，大家多多见谅。如果你现在年轻或迷惘，那你看下这篇文章或许有帮助。如果你想了解社会的底层，也可以看看本文。在这篇文章里我会写一些我对人生的看法，希望可以给各位参考参考。<br /><br />　　我今年二十八岁，个子不高，长得还算端正。在学校受的教育不高，就读到初中二年级下学期。<br /><br />　　我干过很多行业，学过
C#的WinForm开发框架源码 权限管理系统源码数据库 SQL2008源码类型 WinForm
11-16
WinForm开发框架源码 权限管理系统源码 功能描述：01.登录界面 02.系统配置 03.申请账户 04.即时通讯 05.发送消息 06.广播消息 07.软件频道 - 内部通讯录 08.软件频道 - 名片管理 09.软件频道 - 代码生成器 10.系统后台管理 - 用户审核 11.系统后台管理 - 用户管理 12.系统后台管理 - 组织机构管理 13.系统后台管理 - 角色管理 14.系统后台管理 - 员工管理 15.系统后台管理 - 岗位管理 16.系统后台管理 - 用户权限设置 17.系统后台管理 - 角色权限设置 18.系统后台管理 - 组织机构权限设置 19.系统后台管理 - 菜单权限项设置 20.系统后台管理 - 选项管理 21.系统后台管理 - 序号（流水号）管理 22.系统后台管理 - 系统日志 - 按用户访问情况 23.系统后台管理 - 系统日志 - 按用户查询 24.系统后台管理 - 系统日志 - 按菜单查询 25.系统后台管理 - 系统日志 - 按日期查询 26.系统后台管理 - 系统日志 - 系统异常情况记
超级常用的甘特图-项目管理.xlsx
11-16
超级常用的甘特图-项目管理.xlsx
【MRFO栅格地图】蝠鲼觅食算法MRFO栅格地图路径规划（目标函数：最短距离）【含Matlab源码 9168期】.mp4
11-16
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
.f2812.acid
11-16
.f2812.acid
沟通的人性之光——AI 难以取代的人际交流能力.pdf
11-16
沟通的人性之光——AI 难以取代的人际交流能力.pdf
(源码)基于SpringBoot和Redis的分布式数据访问系统.zip
11-16
# 基于Spring Boot和Redis的分布式数据访问系统 ## 项目简介 本项目是一个基于Spring Boot和Redis的分布式数据访问系统，旨在提供高效、可靠的数据库访问和缓存管理功能。系统通过集成Spring Boot框架和Redis数据库，实现了对数据库的读写操作、数据分片、缓存管理等功能，适用于需要高性能和高可用性的分布式应用场景。 ## 项目的主要特性和功能 1. 数据库访问对象（DAO）基类提供通用的数据库访问对象基类，简化数据库操作的配置和管理。支持只读模式和分片数据源的配置。 2. 数据源上下文持有者管理和切换数据库连接，适用于数据库分片的环境。 3. 动态数据源管理实现多数据库的动态管理，支持切换数据库连接。 4. 数据库访问接口（DAO）定义了与数据库交互的基本操作，如增删改查等。 5. 读写分离提供只读和可写的数据访问对象，确保读操作和写操作在不同的环境中进行。
cnpdf_down.php
最新发布
11-16
cnpdf_down.php
25 机床主轴结构优化设计.rar
11-16
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
c++树形数据结构存储族谱
05-14
树形数据结构可以用来存储族谱，每个节点代表一个家庭成员，父节点指向父亲，子节点指向子女。以下是一个用C++实现的树形数据结构存储族谱的示例代码： ```c++ #include #include using namespace std; class ...
评论 56
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

情话0.0

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值