线性表之栈与队列

原创 已于 2025-01-18 20:02:05 修改 · 1k 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #数据结构

于 2024-10-28 21:49:53 首次发布

文章目录

一、栈

　1.何为栈

　2.栈的模拟实现

二、队列

　1.何为队列

　2.队列的模拟实现

前言

在之前我们已经学习了线性表中的顺序表和链表，我们学习了它们的一些基本性质以及如何去实现它们。但是我们在工作时那两种数据类型还远远不够，今天我们再来学习两种线性表（操作受限的线性表），这两种线性表有时候能起到事半功倍的效果。

一、栈

1.何为栈

首先我们先来学习栈，这是一种特殊的线性表，我们规定它只能够从一端存入数据或者取出数据。并且它存储取出还有着  先进后出FILO(first in last out)或者 后进先出LIFO(last in first out) 的顺序特点。

首先我们来介绍几个栈的专用名词：

栈底：我们将栈的一端称作为栈底，我们一般不对栈底数据进行操作；

栈顶：我们将栈的一端称作为栈顶，我们一般都是在栈顶进行各种操作。我们会定义一个指针top用来表示栈顶，top一般指向最后一个有效数据的上面那个空闲空间（这个是重点）；

压栈/入栈/进栈：我们将数据从栈顶存入操作叫做压栈；

出栈：我们将数据从栈顶取出操作叫做出栈；

2.栈的模拟实现

在之前，我们学习顺序表和链表两种线性表，这两种线性表分别是使用数组和链表来实现。现在我们来考虑一下栈该用啥来实现呢？

a)当我们使用数组来实现：我们可以在数组的一端作为栈顶进行插入或者删除数据，其时间复杂度都是O（1），另一端数组下标为0咱们就把它当作栈底。虽然数组大小是一开始就定义好的，但是我们可以使用增容操作（我们增容操作时一般都是成倍增加的，因此增容几次就足够了）

b)当我们使用单链表来实现：当我们对单链表的表尾作为栈顶，然后我们进行插入操作时，其时间复杂度是O（1），但是我们进行删除操作时，其时间复杂度是O(N),因为我们要从头开始遍历整个链表来找到要删除结点的前一个结点。尽管，单链表咱们可以插入一个数据申请一个结点空间，只有不容易浪费空间，但这些结点的空间并不是连续的，因此并不是很好。主要还是时间复杂度上的差异。

c)当我们使用双向链表来实现：当我们将双向链表的一端作为栈顶，另一端作为栈底时，在我们进行插入删除时时间复杂度可能是O（1）。但是，我们将栈底与栈顶换过来时时间复杂度可能就是O(N).

综上所述，我们还是使用数组来实现栈比较合适。接下来，我来用代码进行模拟实现栈，同样的我们需要创建三个文件Stack.c  , Stack.h ,text.c。

这个栈的实现与我们之前的顺序表实现基本是一样的，咱们就不做过多赘述了。

Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int STDataType;
typedef struct Stack
{
	STDataType* arr;//用数组来模拟实现栈
	int capacity;//栈的空间大小
	int top;//栈顶
}ST;

//初始化
void STInit(ST* ps);

//销毁
void STDesTroy(ST* ps);

//入栈
void STPush(ST* ps, STDataType  x);

//出栈
void STPop(ST* ps);

//检查是否为空栈
bool STEmpty(ST* ps);

//读取栈顶数据
STDataType STTop(ST* ps);

//查询有效数据个数
int STSize(ST* ps);

Stack.c

#define  _CRT_SECURE_NO_WARNINGS
#include"Stack.h"


//初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->capacity = ps->top = 0;//当top=0时，即栈顶==栈底时，则表示栈空
}


//销毁
void STDesTroy(ST* ps)
{
	assert(ps);
	if (ps->arr == NULL)
	{
		free(ps->arr);
	}
	ps->capacity = ps->top =0;
}

//入栈
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	//1.判断栈的空间是否足够
	if (ps->capacity == ps->top)//表示栈满了
	{
	//2.增容
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->arr, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("relloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
	//3.入栈
	ps->arr[ps->top++]= x;
}

//出栈
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));//这里面STEmpty的参数是传递地址的，由于ps是栈的指针即地址，故直接传递过去
	ps->top--;
}


//检查是否为空栈
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;//当这个表达式成立时即为空栈，返回true

}

//读取栈顶数据
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->arr[ps->top - 1];
	//注意：咱们将top指向最后一个有效数据的上面一个空闲位置，故我们想要查询时，根据下标就是top-1，注意不能是top--
	//top--==top=top-1,这样就把栈顶改变了
}

//查询有效数据个数
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;//由于数组是从0开始的，并且top指针是指向最后一个有效数据的上面一个空闲位置，所以ps->top就是有效数据的个数
}

test.c

#define  _CRT_SECURE_NO_WARNINGS
#include"Stack.h"
void STtest()
{
	ST st;//定义一个栈
	STInit(&st);
	//入栈4个数字
	STPush(&st, 1);
	STPush(&st, 2);
	STPush(&st, 3);
	STPush(&st, 4);
	//printf("size:%d\n", STTop(&st));
	//STPop(&st);
	//printf("size:%d\n", STTop(&st));
	//STDesTroy(&st);
	//printf("size:%d", STTop(&st));
	//编写一个循环将栈中的所有数据打印出来，注意只能一个一个从栈顶出来，出来一个打印一个直到栈空
	while(!STEmpty(&st))
	{
		STDataType data = STTop(&st);
		printf("%d ", data);
		STPop(&st);
	}
}

int main()
{

	STtest();
	return 0;
}

二、队列

1.何为队列

队列与栈一样，也是一种操作受限的线性表。它只能在一端存入数据，一端取出数据。它有着先进先出FIFO(first in last out)的特点。其实咱们只要稍微联想一下就行，我们平时排队的时候，是不是第一个来的排队首，然后队首的第一个人来进行操作，后面的人只能排到队尾，只能等前面的人都搞完才能轮到他。我们也来介绍一下关于队列的几个名词：

队头：我们把队列的一端当作为队头，我们只能在这一端进行插入操作；

队尾：我们把队列的另一端当作为队尾，我们只能在这一端进行删除操作；

入队：我们将数据存入队列的操作叫做入队。这个操作只能够在队头进行；

出队：我们将数据取出队列的操作叫做出队。这个操作只能在队尾进行。

2.队列的模拟实现

这个队列我们该用什么来进行实现呢？如果使用数组来实现的话，由于数组一端是不变的，我们无法对那一端进行操作，因此数组这个不行。然后，我们可以使用单链表来实现。链表中有头插尾插，头删尾删等操作，但是，尾插操作中，其时间复杂度是O（n),于是我们可以创建两个指针，一个头指针head，一个尾指针tail,那么我们尾删，头删的时间复杂度都是O(1)。接下来我们用代码来实现队列，同样我们用三个文件Queue.c,Queue.h,test.c来进行实现

Queue.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int QDatatype;
//定义队列结点
typedef struct QueueNode
{
	QDatatype data;
	struct QueueNode* next;
}QNode;

//定义队列
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

//初始化
void QInit(Queue* pq);

//销毁
void QDetroy(Queue* pq);

//判断队列是否为空
bool QEmepty(Queue* pq);

//入队列
void QPush(Queue* pq,QDatatype x);

//出队列
void QPop(Queue* pq);

//读队头数据
QDatatype QFront(Queue* pq);

//读队尾数据
QDatatype QBack(Queue* pq);

//队列有效数据个数
int	 QSize(Queue* pq);

Queue.c

#define  _CRT_SECURE_NO_WARNINGS
#include"Queue.h"

//初始化
void QInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

//销毁
void QDetroy(Queue* pq)
{
	assert(pq);
	assert(!QEmepty(pq));
	QNode* pcur = pq->head;
	while (pcur)
	{
		QNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;

}

//判断队列是否为空
bool QEmepty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL && pq->tail == NULL;
}

//入队列(队尾入）
void QPush(Queue* pq, QDatatype x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	//将新的结点初始化一下
	newnode->data = x;
	newnode->next = NULL;
	//队列为空
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = pq->tail->next;
	}
	pq->size++;
}

//出队列（队头出）
void QPop(Queue* pq)
{
	assert(pq);
	assert(!QEmepty(pq));
	//当只有一个结点时
	if (pq->head == pq->tail)
	{
		free(pq->head);
		//将尾指针也置为NULL，否则就成为野指针了
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* NEXT = pq->head->next;
		free(pq->head);
		pq->head = NEXT;
	}

	pq->size--;
}

//读队头数据
QDatatype QFront(Queue* pq)
{
	assert(pq);
	assert(!QEmepty(pq));
	return pq->head->data;
}


//读队尾数据
QDatatype QBack(Queue* pq)
{
	assert(pq);
	assert(!QEmepty(pq));
	return pq->tail->data;
}

//队列有效数据个数
int	 QSize(Queue* pq)
{
	assert(pq);
	assert(!QEmepty(pq));
	return pq->size;
}

test.c

#define  _CRT_SECURE_NO_WARNINGS
#include"Queue.h"

void Queuetest()
{
	Queue q;
	QInit(&q);
	QPush(&q, 1);
	QPush(&q, 2);
	QPush(&q, 3);
	QPush(&q, 4);
	
	printf("head: %d\n", QFront(&q));
	printf("tail: %d\n", QBack(&q));

}

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

总结

这次我们学习的这两种线性表是两种操作受限的线性表，但是它们两个的实现方式是基于之前的顺序表和链表，因此，我们不仅要学习现在的，也要熟练掌握之前所学过的。有句老话怎么说来着：温故而知新，可以为师矣。

简述线性表、栈和队列的异同
weixin_63292027的博客
09-01 1026
简述线性表、栈和队列的异同
数据结构——线性表之 栈 和 队列，详细解析
昵称就是昵称吧的博客
04-12 2091
可以先了解线性表的无头单向非循环链表(单链表)---数据结构——单链表的增加、删除、查找、修改，详细解析_昵称就是昵称吧的博客-CSDN博客，和线性表的带头双向循环链表---数据结构：带头双向循环链表——增加、删除、查找、修改，详细解析_昵称就是昵称吧的博客-CSDN博客 一、线性表之栈 1、栈的表示和实现 1.1栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除。操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO..
数据结构:线性表(栈的实现)
想学好c++的oMen的博客
09-05 396
文章实现了动态栈,附有代码解析
【数据结构】线性表——栈与队列
Bucai_不才的博客
11-12 1597
深度剖析了栈与队列这两种线性表数据结构，介绍了栈与队列的基本概念、操作方法及应用场景，为了深入了解栈与队列，为此特地编写"队列模拟实现栈"与"栈模拟实现队列"，深入浅出。
数据结构之线性表，栈和队列
2301_79407040的博客
11-23 1264
因此，为了表示每个数据元素ai与其直接后继元素ai+1之间的逻辑关系，对数据ai来说，除了存储其本身的信息之外，还需要存储一个指示其直接后继的信息（即直接后继的存储位置）。只要确定好了存储线性表的起始位置，线性表中任一数据元素都可以随机存取，所以线性表的顺序存储结构是一种随机存取的储存结构，我们通常用动态内存开辟的方法来开辟顺序表内存。采用顺序存储时,逻辑上相邻的元素,对应的物理存储位置也相邻。而采用链式存储时,逻辑上相邻的元素,物理存储位置则不一定相邻,对应的逻辑关系是通过指针链接来表示的。
数据结构线性表之栈与队列
fjhugjkdsd的博客
02-28 631
本文主要介绍线性表下的栈与队列的基本概念以及相关代码(C语言版)。附加栈与队列在线OJ习题的练习。
线性表——栈和队列
weixin_59055853的博客
08-14 1302
快进来康康！！线性表第三关——栈和队列
第二章：线性表、栈和队列
WANGHAOXIN364的博客
02-13 2101
什么是线性表？ 线性表是由n个相同类型的数据元素组成的有限序列，它是最基本的一种线性结构。顾名思义，线性表就像是一条线，不会分叉。线性表有唯一的开始和结束，除了第一个元素外，每个元素都有唯一的直接前驱，除了最后一个元素外，每个元素都有唯一的直接后继。线性表有两种存储方式，分别是顺序存储和链式存储。采用顺序存储的线性表称为顺序表，采用链式存储的线性表称为链表。链表又分为单链表、双向链表和循环链表。 顺序表：顺序表采用顺序存储方式，元素存储是连续的，中间不允许有空，因此顺序表可以快速定位是第几个...
线性表、栈与队列
记昨日书
01-30 571
线性表、栈与队列 关于线性表的一些基本操作，以及如何利用线性表实现栈和队列 线性表的类型定义 线性表实现栈 线性表实现队列 线性表的类型定义及基本操作 线性表是n个性质相同的数据元素的有限序列。 在复杂的线性表中，一个数据元素可以由若干个数据项组成。其中常把数据元素称为记录，含有大量记录的线性表又称文件。 线性表的十二种基本操作： （对线性表内部元素有改变时加&符号）
数据结构之线性表、栈和队列的应用特性及实现方式解析
03-21
内容概要：本文档详细介绍了线性表、栈以及队列的基本概念，探讨了它们之间的联系与区别。主要内容涵盖各自的操作特点——比如插入和删除的位置，所遵循的数据存取逻辑规则分别是无限制、后进先出（LIFO）、先进先出...
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
### 【计算机科学】数据结构基础概念与实现：线性表、栈、队列及二叉树操作解析
04-09
内容概要：本文档是关于数据结构的学习笔记，涵盖了线性表、栈、队列、二叉树等多种基本数据结构及其操作实现。文中详细介绍了各种数据结构的特点、存储方式（如顺序存储和链式存储）、常见操作（如插入、删除、遍历...
算法第四十三天：动态规划第四十三天part10（第九章）
m0_71209549的博客
08-13 208
可通过滚动数组优化到 O(min⁡(m,n))O(\min(m, n))O(min(m,n))。第一行、第一列全部为 0（额外加一行一列的 0，避免越界）。mmm 和 nnn 分别为两个数组的长度。结尾的最长公共子数组的长度。保存遍历过程中遇到的最大。2.最长连续递增序列。
自由学习记录（82）
red_redemption的博客
08-13 402
文章摘要： 本文详细介绍了Bitonic排序算法的实现，包括其递归分治结构、位元合并操作以及数组补齐处理。算法通过将输入数组补全为2的幂次长度，执行递归排序和合并操作，最后裁切结果。文章还探讨了GPU动画烘焙技术，将骨骼动画预计算为顶点序列缓冲区，实现实例化共享动画数据。同时介绍了力场影响器系统，通过ComputeBuffer传递位置/力参数来操控群体行为，并提供了性能优化建议，如内存对齐、缓冲区管理和渲染时序控制。在渲染管线部分，对比了VFX Graph与传统粒子系统的差异，阐述了URP中自定义渲染通道的
机械学习--DBSCAN 算法（附实战案例）
enlybbq的博客
08-10 1242
聚类效果：DBSCAN 成功将啤酒分为 3 个有意义的簇（常规啤酒、轻量啤酒、高端啤酒），并识别出 4 种特征异常的啤酒（噪声点），符合实际产品分类逻辑。参数影响：ε=0.6 和 MinPts=5 的组合效果较好，若 ε 增大，可能将噪声点划入簇；若 MinPts 增大，可能导致簇分裂为更多小簇。应用价值：该结果可辅助啤酒企业定位产品市场、优化产品线，或为消费者提供基于特征的选购参考。
无人机开发分享——基于行为树的无人机集群机载自主决策算法框架搭建及开发
Vesan的博客
08-06 693
* 在之前的开发分享中，我们分享了机载端开发任务管理、协同控制、无人机平台接口等一系列模块软件，但是要想实现真正的无人机高度智能化，机载的自主决策模块功能必不可少。机载自主决策模块主要实现无人机集群任务过程中地面任务获取分析、战场实时态势分析与自主决策，可在断连或自主模式时对作业中的无人机集群进行决策与控制，减少地面交互，提升任务效率。下面我们对机载自主决策模块的开发进行介绍。**
排序概念、插入排序及希尔排序
2503_92099422的博客
08-09 869
c.虽然很多算法本身具有稳定或不稳定排序性质但是任何排序只要稍作修改就可以修改稳定性，例如在冒泡排序中判断交换顺序的依据是if(a>b)只要变成if(a>=b)就可以破坏稳定性。2.内部排序和外部排序：待排序数据可以一次性载入到内存中为内部排序，反之数据量过大就是外部排序。3.稳定排序：排序前后序列中键值相等的元素在相对位置不发生变化的就是稳定排序。就地排序只是在原数组空间进行排序处理，也就是输入的数组和得到的数组是同一个。3.如果待排序的元素，已经有序，只有极个别的元素是无序,插入速度较快。
cdq 分治优化 dp
m0_60506105的博客
08-13 130
upd：原来的 cdq 分治内容太多了，于是考虑将 dp 部分分离出来。cdq 分治，其具有一个log就能搞定一维的优美性质，适用于一些带有偏序条件的 dp 转移式。
【密码学实战】国密SM2算法介绍及加解密/签名代码实现示例
最新发布
开源代码仓：https://gitcode.com/openHiTLS/openhitls
08-13 681
SM2 的诞生不仅是技术突破，更是国家信息安全战略的重要布局。其基于椭圆曲线密码学（ECC）的设计，在同等安全强度下，密钥长度仅为 RSA 的 1/10，运算效率提升数倍。SM2 已成为 ISO/IEC 国际标准，并深度融入国产密码生态体系，为构建安全可靠的网络安全架构提供了坚实支撑。本文通过代码示例为开发者提供SM2实现参考
未来AI：微算法科技（NASDAQ:MLGO）开发基于忆阻器网络储层计算MemristorPattern虚拟平台
MicroTech2025的博客
08-13 248
其灵活性和可调整性使其成为未来机器学习硬件中的创新力量，为实际问题提供了高效、智能的解决方案，通过结合电路模拟和数值仿真，平台为研究人员提供了深入理解和优化基于忆阻器网络的储层计算系统的工具。微算法科技（MLGO）的MPVP仿真平台技术方面注重了模拟整个基于忆阻器网络的储层计算系统的行为，带来了跨越的技术创新，也为机器学习硬件的发展提供了有力的支持。存储器部分通过动态存储器响应捕捉输入信号的模式和特征。仿真平台的成功开发为构建可靠、高性能的机器学习硬件奠定了坚实的基础，为未来的技术创新开辟了新的可能性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值