栈和队列详解（C语言版）

最新推荐文章于 2024-08-06 14:20:04 发布
最新推荐文章于 2024-08-06 14:20:04 发布
阅读量834 收藏 6
点赞数 24
分类专栏： 数据结构 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72637272/article/details/139117409
版权

一、栈

1.栈的定义和结构

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

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

出栈：栈的删除操作叫做出栈。出数据也在栈顶。

2.栈的实现 

栈和线性表类似，也有两种存储表示方法数组和链表。相对而言数组的结构更优一点！由于栈在使用的过程中所需要的大小难以估计，所以通常是先为栈分配一个基本容量，然后再使用的过程中，当栈的空间不够使用的时候再继续追加存储空间。所以接下来的说明是使用数组实现动态增长的栈的示例。

2.1定义结构体

typedef int STDataType;//方便后续修改类型数据
typedef struct Stack
{
	STDataType* a;
	int top;//栈顶
	int capacity;//容量
}ST;

2.2初始化和销毁

因为这里初始化top = 0 所以这里的top指向的是栈顶元素的下一个位置，这里需要注意一下！！

那我们这里使用top = 0好处是什么呢！top即存储数据的个数！

因为当新增了数据top++，就如图所示：

void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;//这里使用0的话就是顶元素的下一个位置，获取顶元素需要-1
}
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

 top = 0 意味着栈顶元素的下一个位置

top = -1 意味着top即栈顶元素 

 

2.3入栈

这里我们需要注意一下！因为我们需要判断栈是否满了，如果满了需要开辟空间

这里没有malloc就使用realloc，为什么呢？因为如果需要调整的位置为0，就相当于malloc!

void STPush(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,sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc is failed");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

2.4出栈

这里需要注意一下栈是否为空，若是为空则不能在删除

void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);//没有东西就别删了
	ps->top--;//直接访问不到此下标
}

2.5获取栈顶元素

这里要注意top指向的是栈顶元素的下一个位置，所以下标需要是top-1

STDataType STTop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}

2.6返回元素个数

top即元素个数，直接返回即可

STDataType STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

2.7判断栈是否为空

bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;//真：空的话返回1；假不空返回0
}

 2.8完整代码

 #include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
 
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST* ps);
void STDestroy(ST* ps);

void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
STDataType STTop(ST* ps);

STDataType STSize(ST* ps);

bool STEmpty(ST* ps);


void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;//这里使用0的话就是顶元素的下一个位置，获取顶元素需要-1
}
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}
void STPush(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,sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc is failed");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);//没有东西就别删了
	ps->top--;//直接访问不到此下标
}

STDataType STTop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}
STDataType STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;//真：空的话返回1；假不空返回0
}

二、队列

1.队列的定义及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO（First In First Out）入队列

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

进行删除操作的一端称为队头

结构图：

2.队列的实现

2.1结构体定义

栈和线性表类似，也有两种存储表示方法数组和链表。相对而言数组的结构更优一点！

这里使用的是单向不带头不循环链表实现

这里定义两个指针方便修改，否则需要传二级指针去修改结构体指针

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;
//定义两个结构体是为了方便修改，否则要传二级指针进去修改结构体指针

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Que;

两个结构体之间的关系 

 

 

 

2.2初始化

void QueueInit(Que* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

2.3入队

首先判断是否为空指针

判断是否满了，需要开新空间

void QueuePush(Que* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc is failed");
		exit(-1);
	}
	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++;
}

解释图

2.4出队列 

要判断是不是空指针传入，其次要判断此链表是不是为空，若为空则报错

还要区分只有一个节点和很多节点的区别

void QueuePop(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}

解释图 

2.5获取队头和队尾数据 

首先判断是否传入指针为空，直接返回头尾指针指数据即可

QDataType QueueFront(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}
QDataType QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;

}

 2.6判断队列是否为空

bool QueueEmpty(Que* pq)
{
	assert(pq);
	return pq->head == NULL;
}

2.7计算节点个数

直接返回size

int QueueSize(Que* pq)
{
	assert(pq);
	return  pq->size;
}

2.8销毁队列

void QueueDestroy(Que* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->size = 0;
	pq->head = pq->tail = NULL;
}

2.9全部代码

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


typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;
//定义两个结构体是为了方便修改，否则要传二级指针进去修改结构体指针

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Que;

void QueueInit(Que* pq);
void QueueDestroy(Que* pq);
void QueuePush(Que* pq, QDataType x);//相当于尾删
void QueuePop(Que* pq);//相当于头删
bool QueueEmpty(Que* pq);
int QueueSize(Que* pq);
QDataType QueueFront(Que* pq);
QDataType QueueBack(Que* pq);


#include "Queue.h"
void QueueInit(Que* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
void QueueDestroy(Que* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->size = 0;
	pq->head = pq->tail = NULL;
}
void QueuePush(Que* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc is failed");
		exit(-1);
	}
	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(Que* pq)//相当于头删
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}
QDataType QueueFront(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}
QDataType QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;

}
bool QueueEmpty(Que* pq)
{
	assert(pq);
	return pq->head == NULL;
}
int QueueSize(Que* pq)
{
	assert(pq);
	return  pq->size;
}

能不能不困啊
关注
专栏目录
C语言 表、栈和队列详解及实例代码
01-20
C语言 表、栈和队列详解 表ADT  形如A1,A2,A3…An的表，这个表的大小为n，而大小为0的表称为空表，非空表中，Ai+1后继Ai，Ai-1前驱Ai，表ADT的相关操有PrintList打印表中的元素；CreateEmpty创建一个空表；Find...
《数据结构C语言版》——栈和队列详解(图文并茂)，从零开始的学习
青春无问西东 岁月自成芳华
04-20 4744
一文搞懂数据结构系列之栈和队列部分，从0基础到快速手敲数据结构，小白也能轻松看懂的宝典！
【数据结构】—手把手带你用C语言实现栈和队列（超详细！）
B1ue还在专注
08-07 1912
本文为作者对于栈和队列的学习总结，在写本文的过程中，作者重新捋了一遍一遍这两个数据结构，相信按照循序渐进的思路对于读者会有所帮助♪(･ω･)ﾉ
数据结构之栈和队列(C语言版)
跃渊的博客
07-18 911
以上我们就讲完了栈和队列这两个数据结构，希望对大家有帮助，欢迎大家批评指正！
C语言 数据结构 栈和队列
CR7lmz的博客
07-27 216
一、栈 1、栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 2、栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些...
C语言——栈和队列
super_coders的博客
05-14 505
ps->a我们有两种初始化方法，一种是直接malloc一个空间，可以是四个或者八个对象的空间，也可以像我一样，先不开，等会入栈的时候再开。栈是一种特殊的线性表，限定仅在表尾进行插入和删除的线性表。在进行入栈以前，先把top指向为栈顶的下一个数据，如果指向栈顶数据的话，初始化就不能为0。队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。栈的实现一般使用数组或者链表，因为cpu高速缓存的原因，使用数组也非常ok。希望这篇博客对你有所帮助！头文件：Queue.h。
数据结构（C语言版） 第三章 栈与队列 知识梳理 + 作业习题详解1
08-03
在C语言版的数据结构中，栈和队列是两种基础且重要的数据结构，它们广泛应用于算法设计和程序实现中。以下是关于这两部分的知识点梳理： 一、栈 栈是一种后进先出（LIFO）的数据结构，其特点是只允许在一端（栈顶...
c语言指针和结构体链表详解ppt课件.ppt
11-20
在实际应用中，链表可以用于实现各种数据结构，如队列、栈、树等。链表的优点是可以动态地增加或删除元素，不需要预先分配固定的内存空间。但是，链表也存在一些缺点，如链表的遍历速度较慢，且链表的插入和删除操作...
数据结构PPT详解（C语言版）
08-20
全书共7章，内容包括绪论，线性表，栈和队列，串、数组和广义表，树和二叉树，图，查找和排序。全书采用类C语言作为数据结构和算法的描述语言。 数据结构是带有结构特性的数据元素的集合，它研究的是数据的逻辑结构...
C语言-栈和队列
m0_73605503的博客
07-22 1302
欢迎来到HanLop博客的C语言数据结构初阶系列。在之前的文章中，我们详细介绍了链表及其操作方法。在本篇文章中，我们将深入探讨栈和队列这两种常见的数据结构。栈和队列虽然都是线性数据结构，但它们在数据的存取方式上有着显著的区别。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。通过理解和掌握这两种数据结构，您将能更有效地管理数据，并为后续更复杂的数据结构和算法的学习打下坚实的基础。让我们一起开始探
C语言数据结构（超详细讲解）| 栈和队列的实现
m0_74951730的博客
05-14 1180
本篇博客将深入探讨栈和队列的实现原理以及它们在C语言中的实现方式。我们将从基本概念开始，逐步深入，通过代码示例和实际应用场景，带领读者领略这两种数据结构的魅力所在。
c语言--栈和队列
weixin_61558111的博客
09-24 1965
栈的入栈和出栈操作 通常用指针top指向栈顶的位置，用指针bottom指向栈底，栈顶指针top动态反映栈的当前位置。栈是一种特殊的线性表，因此栈可采用顺序存储结构存储，也可以使用链式存储结构存储。栈中的数据元素用一个预设的足够长的一维数组来实现：。栈底位置可以设置在数组的任意端点，用来作为栈顶指针。 若现在有一个栈，StackSize是5，则栈的普通情况、空栈、满栈的情况分别如下图所示： 通常将0下标端设为栈底，这样空栈时栈顶指针s->top = -1；入栈时，栈顶指针s->top++；出栈时，s->
c语言数据结构之栈和队列
最新发布
2401_84272030的博客
08-06 711
c语言数据结构之栈和队列
数据结构——栈和队列（C语言实现）
m0_56399733的博客
07-17 1233
栈和队列是两种重要的线性结构，本次主要对其顺序栈，链栈，顺序队列，链队进行学习，并用C语言对其进行实现。
数据结构之用C语言实现栈和队列
swb200616的博客
07-27 764
栈是一种特殊的线性表，其只允许在固定的一端进行元素插入和删除操作。我们将进行元素插入和删除操作的一段成为栈顶，另一端成为栈底，其栈中的元素出入顺序我们遵循先进先出的原则。与我们将栈的插入操作叫做，将栈的删除操作成为。我们用一个图来形象的表示一下栈。在图中我们可以看到栈顶位置永远在最上面的那个元素所在的位置，我们也是在栈顶位置进行插入删除操作的，我们形象的把栈画作一个开一口的杯子，我们对杯子无法对底部进行操作，我们只能在杯顶进行操作。
【初阶数据结构】栈和队列——C语言（详解）
qq_55119554的博客
09-16 809
C语言实现栈和队列，通俗易懂。
C语言数据结构：栈和队列
qq_42319810的博客
07-02 2080
define MaxSzie 10 //定义栈中元素的最大个数//静态数组存放栈中元素int top;//栈顶指针}SqStack;//初始化栈S.top = -1;//初始化栈顶指针SqStack S;//声明一个顺序栈（分配空间）.....//判空操作else//数据域//指针域}*LiStack;//栈类型定义队列（Queue）是只允许在一端进行插入，在另一端删除的线性表重要术语：队头、队尾、空队列。
C语言数据结构——栈和队列
zcxmjw的博客
12-27 394
本篇文章主要带领大家深入了解栈和队列以及相关实现。
C语言中的栈与队列详解
"本章主要介绍了C语言中的栈和队列概念，包括它们的存储结构、基本操作以及实际应用。栈是一种后进先出（LIFO）的数据结构，常用于递归处理；队列则是一种先进先出（FIFO）的数据结构，广泛应用于任务调度和数据传输...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值