【数据结构初阶】栈和队列（C语言实现+图解）

已于 2022-08-27 22:38:59 修改
阅读量1.9k 收藏 8
点赞数 15
分类专栏： 数据结构 文章标签： 数据结构 链表 c语言
于 2022-08-27 22:30:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58124165/article/details/126556862
版权

文章目录

栈

栈的概念及结构

栈：是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

压栈： 从栈顶放入数据的操作被称为压栈，也可以叫做进栈、入栈。

出栈： 删除栈顶数据的操作被称为出栈，也可以叫做弹栈。
在这里插入图片描述

栈的实现

栈的实现一般可以使用数组或者链表实现。那如何选择呢？我们来分析一下。

链表栈： 如果选择单链表的话，我们因该选头结点当栈顶，尾结点当栈底，否则，每次存取数据的时候都必须遍历链表，其次，需要频繁的申请结点，对内存会有一定损耗。所以如果选链表栈的话，推荐选择双向链表会比较好点。

数组栈： 对于数组栈来说，访问栈顶的时间复杂度为O(1)，虽动态增容时会有一定的消耗，在增容次数不会很多。所以相比链表栈，数组栈更优。
所以下面我们用顺序表来实现栈

栈结构体定义

结构如下

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;//指向为栈开辟的空间
	int top;//指向栈顶，相当于顺序表中的size
	int capacity;//容量
}ST;
栈的接口

栈实现的接口主要有以下几个：

//初始化
void StackInit(ST* ps);
//销毁
void StackDestroy(ST* ps);
//入栈
void StackPush(ST* ps, STDataType x);
//出栈
void StackPop(ST* ps);
//取栈顶元素
STDataType StackTop(ST* ps);
//判空
bool StackEmpty(ST* ps);
//计算栈中元素个数
int StackSize(ST* ps);
栈的初始化

代码实现：

//初始化
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

注意：top可以初始化为0，也可以初始化为-1

  • 若为0，则top为栈顶元素的下一个位置，其值代表元素个数
  • 若为-1，则top为当前栈顶元素的下标，其值+1才代表元素个数

在这里插入图片描述

栈的销毁

为了防止内存泄露，动态内存申请的空间一定要我们自己手动释放，养成一个良好的习惯。

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

入栈就是在栈顶插入数据，在插入数据之前，我们需要考虑扩容的问题，当ps->top == ps->capacity的时候，就需要扩容了，扩容和顺序表一样每次扩一倍，这样可以减少扩容的次数，但同时可能会带来一定的空间浪费。
在这里插入图片描述
代码实现

//入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	//需要判断栈是否满了,满了就要扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;

		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
出栈

出栈就是删除栈顶的元素，也就是top-1指向的位置，所以我们只需将top减一操作即可。
我们在出栈的过程中还需注意一点，就是栈是否为空，如果为空，就不能进行操作
在这里插入图片描述

代码实现：

//出栈
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	ps->top--;
}
取栈顶元素

因为栈顶元素的下标是top-1，所以我们只需返回top-1位置的元素即可。同时我们也需要注意栈是否为空

代码实现：

//取栈顶元素
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->a[ps->top - 1];
}
判断栈是否为空

因为我们的top是初始化为0，其值代表栈中元素的个数，所以，当top == 0就代表栈空。

代码实现：

//判空
bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}
栈的元素个数

top就是栈中元素的个数，返回top即可

代码实现：


//计算栈中元素个数
int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

完整代码

//初始化
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

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

//入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	//需要判断栈是否满了,满了就要扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;

		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

//出栈
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	ps->top--;
}

//取栈顶元素
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->a[ps->top - 1];
}

//判空
bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

//计算栈中元素个数
int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

队列

队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)的原则
请添加图片描述
队头： 进行删除操作的一端称为队头

队尾： 进行插入操作的一端称为队尾

入队列即在队尾插入数据，出队列则是在队头删除数据。

队列的实现

队列也可以使用数组和链表来实现，我们选择使用单链表来实现，只需进行头删和尾插，如果使用数组的话，那么每一次删头，我们都需要挪动数据，效率不高。

队列结构体定义

定义结构如下：

typedef int QDataType;
//结点
typedef struct QueueNode
{
	struct Queue* next;
	QDataType data;
}QNode;
//队列
typedef struct Queue
{
	QNode* head;//记录链表的头
	QNode* tail;//记录链表的尾
	int size;//记录队列的元素个数
}Queue;

队列需要两个指针标识队头和队尾，以便管理队列的元素。而队列元素即结点用单链表的结构实现即可。把结点封装成一个结构体，队列再封装成一个结构体存入指向结点结构体的指针。

如果不定义Queue结构体或者是说不将 头尾指针 封装起来的也是可以的，不过这样我们在传参时就需要使用二级指针了。

void QueueInit(QNode** pphead, QNode* pptail);
队列的接口

队列实现的接口主要有以下几个：

//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDestroy(Queue* pq);
//入队
void QueuePush(Queue* pq, QDataType x);
//出队
void QueuePop(Queue* pq);

//取队头元素
QDataType QueueFront(Queue* pq);
//取队尾元素
QDataType QueueBack(Queue* pq);

//判空
bool QueueEmpty(Queue* pq);

//计算队列大小
int QueueSize(Queue* pq);
队列的初始化

代码实现：

//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
队列的销毁

代码实现：

//销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;

	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;
		free(del);
	}
	pq->head = pq->tail = NULL;
}

初始化和销毁并没有传二级指针，因为传递的是队列结构体的地址，而两个头尾指针是封装在队列结构体里的。创建队列在函数外，所以传其地址就行，同时加上断言以防空指针。

入队

入队其实就是单链表尾插的操作，进行尾插需要判断链表为不为空。
为空时需要改变头尾指针的指向，不为空就不需要了。
在这里插入图片描述

代码实现：

//入队
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	//首先需要申请一个新结点
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;
	}

	//队列为空
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	//队列不为空
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}
出队

出队其实就是单链表头删的操作，进行头删时，需要注意链表是否为空，还需要考虑当链表只有一个结点的情况

在这里插入图片描述

代码实现：

//出队
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//判断链表是否为空

	//只有一个元素
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail =  NULL;
	}
	//多个元素
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;
		free(del);
		del = NULL;
	}
	pq->size--;
}
取队头和队尾元素

取队头元素就是返回头结点的数据，取队尾元素就是返回尾结点的数据

代码实现：

//取队头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}
//取队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}
判断队列是否为空

当pq->head==NULL且pq->tail==NULL则链表为空

代码实现：

//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL && pq->tail == NULL;
}
统计队列元素个数

队列结构体中的size就是统计队列元素的个数

代码实现：

//计算队列中元素的个数
int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

完整代码

//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
//销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;

	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;
		free(del);
	}
	pq->head = pq->tail = NULL;
}
//入队
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	//首先需要申请一个新结点
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;
	}

	//队列为空
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	//队列不为空
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}
//出队
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	//只有一个元素
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail =  NULL;
	}
	//多个元素
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;
		free(del);
		del = NULL;
	}
	pq->size--;
}

//取队头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}
//取队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL && pq->tail == NULL;
}

//计算队列大小
int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}
Clumsy、笨拙
关注
专栏目录
C语言实现数据结构算法初阶算法
06-15
C语言作为底层编程的首选语言，它提供了直接操作内存的灵活性，因此用C语言实现数据结构和算法可以深入理解这些概念的本质。下面将详细介绍标题和描述中提到的几个核心知识点。 1. **顺序表**：顺序表是一种基本的...
栈及栈的基本操作
hmh520i的博客
03-23 466
栈与栈的基本操作
顺序栈的插入和删除
Lookdrama的博客
10-22 4349
栈（Stack）是一种特殊的线性表，它所有的插入和删除都限制在表的同一端进行。
C语言算法—栈、队列、纸牌游戏问题
weixin_45832286的博客
01-20 4181
问题： 小猫钓鱼纸牌游戏： 两个人一起玩纸牌游戏，将一副扑克牌平均分成两份，其中一个人先将自己手中的第一张扑克牌放在桌上，然后另一个人也拿出手中的第一张扑克牌，并放在刚刚第一张扑克牌的上面，就像这样，两个人交替出牌，出牌时。如果某人打出的牌与桌上某张牌的牌面相同，即可将两张相同的牌及其中间所夹的牌全部取走，并依次放在自己手中牌的末尾，当任意一个人的手中牌全部出完时，游戏结束，对手获胜。（这里假设开...
数据结构——栈与队列(C语言)
xiaobai06的博客
08-05 932
栈与队列的定义和特点 栈的定义和特点 栈是限定仅在表尾进行插入或删除操作的线性表。因此，对栈来说，表尾有其特殊含义，称为栈顶，相应地，表头端称为栈底。不含元素的空表称为空栈。 假设栈S=(a1a_1a1​,a2a_2a2​,···,ana_nan​)，则称a1a_1a1​为栈底元素，ana_nan​为栈顶元素。栈中元素按a1a_1a1​，a2a_2a2​，····，ana_nan​的次序进栈，退栈...
数据结构第二部分——栈和队列(C语言版)
I wanna be myself, where I Belong.
11-07 727
队列：它是一种操作受限的线性表，限制为仅允许在一端插入，另一端删除，插入的一端称为队尾，删除的一端称为队头。栈：只能在一端进行插入或删除的线性表，这一端称为栈顶，另一端称为栈底。，就像一个车队开进了一个死胡同，最先开进的车只有等后边的车全部出去，它才能出去。
C初阶/C进阶/数据结构初阶（C语言版）
12-04
c语言
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
本资料包"初阶数据结构+高阶数据结构，分别用c、c++来实现.zip"包含了使用C和C++语言实现的数据结构实例，旨在帮助初学者和进阶者深化对数据结构的理解。 首先，让我们从初阶数据结构开始。基础的数据结构通常包括...
c、c++初阶数据结构+高阶数据结构.zip
12-09
c、c++初阶数据结构+高阶数据结构.zip
数据结构初阶数据结构初阶
最新发布
02-12
2. **栈和队列**：栈是后进先出（LIFO）的数据结构，常用于函数调用、表达式求值等；队列是先进先出（FIFO）的数据结构，常用于任务调度和消息传递。 3. **树形数据结构**：包括二叉树、平衡树、堆等。二叉树每个...
数据结构与算法--用c语言建立栈以及其相关操作
m0_70659080的博客
05-31 3324
关于栈的有关介绍
栈的基本操作（C语言实现）创建，销毁，入栈，出栈
m0_74774759的博客
04-22 2190
栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
数据结构复习（栈和队列）
努力的程序员
06-01 8352
数据结构复习题（3）栈和队列选择题填空题判断题 栈和队列 选择题 1、一个栈的输入序列为：a，b，c，d，e，则栈的不可能输出的序列是（ ）。 A. a,b,c,d,e B. d,e,c,b,a C. d,c,e,a,b D. e,d,c,b,a 2、判断一个循环队列Q（最多n个元素）为满的条件是（ ）。 A. Q->rear==Q->front B. Q->rear==Q->front+1 C. Q->front==
数据结构——栈和队列及其实现（C语言）
fsbwb的博客
05-19 406
本篇文章是在介绍栈和队列的相关概念及其用C语言的实现。
C语言实现顺序队列的各种操作
weixin_44754772的博客
04-16 2408
C语言-顺序队列的基本操作 一、我们先明确一下什么是队列？ 队列(Queue)：只允许在表的一端进行插入，另外一端进行删除 入队/进队：插入元素 出队/离队：删除元素 队头：允许删除的一端 队尾：允许插入的一端 二、顺序队列的存储结构是怎样的呢？ 队列的顺序存储结构如下： 我们开辟了12个连续的int型存储空间，10个存储数据，1个存储队头指针，1个存储队尾指针。 #include<stdio.h> #include<stdlib.h> #define MaxSize 10 typ
顺序表的插入与删除（简单版）--C语言
学习日记
11-16 8742
如标题，只是一个简单的顺序表的插入和删除，希望能帮到各位初学的同学。只起参考作用
C语言实现顺序表：插入和删除
weixin_63301726的博客
10-05 1574
C语言实现顺序表：插入和删除
C语言数据结构篇——顺序表的理解，创建，插入和删除
weixin_47681530的博客
09-18 545
拓展
数据结构之栈
qq_53010164的博客
04-08 2907
一、栈 （1）栈的概念： 是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。 进行数据插入和删除的一端称为栈顶，另一端称为栈底。栈中的数据元素遵循后进先出或者先进后出的原则。 如图： （2）压栈：栈的插入操作叫做进栈、压栈或者入栈，从栈顶压入数据 出栈：栈的删除操作叫做出栈。出数据也在栈顶 如图 进栈： 如图 出栈： （3）栈的实现：栈的 实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小 如图 ...
掌握C/C++实现的初阶与高阶数据结构
C语言和C++语言在实现这些数据结构时，各有优势，C语言因为其接近硬件的特性，通常用于实现更底层、效率更高的数据结构；而C++则由于其面向对象的特性和丰富的库支持，使得实现复杂的数据结构更为便捷和安全。本资源...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Clumsy、笨拙

你的鼓励是我最大的动力

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

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

打赏作者

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

抵扣说明：

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

余额充值