栈和队列

已于 2024-09-06 11:58:23 修改
阅读量524 收藏 7
点赞数 24
分类专栏： C语言——初阶数据结构 文章标签： 栈和队列 c语言
于 2024-09-02 20:49:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80310672/article/details/141788757
版权

目录

栈

1、栈的概念及结构

 2、栈的实现

2.1 top的指向

2.2 动态增长顺序栈

2.2.1 Stack.h

2.2.2 Stack.c

2.3 链式堆栈

2.3.1 Stack.h

2.3.2 Stack.c

队列

1、队列的概念及结构

2、队列的实现

2.1 链式队列

2.1.1 Queue.h

2.1.2 Queue.c

2.2 顺序循环队列

2.2.1 Queue.h

2.2.2 Queue.c

Tips：

1、栈(一般实现顺序栈)

2、队列(一般实现链式队列)

栈

1、栈的概念及结构

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

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

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

 2、栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

2.1 top的指向

两种指向没什么区别，以下采取top指向栈顶数据的下一个位置 即 top指向待插入的位置

2.2 动态增长顺序栈

2.2.1 Stack.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>


// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);
2.2.2 Stack.c
#include "Stack.h"

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}

//动态申请
void Stackcapacity(Stack* ps)
{
	if (ps->_top == ps->_capacity)
	{
		ps->_capacity = ps->_capacity == 0 ? 4 : 2 * ps->_capacity;
		STDataType* tmp = (STDataType*)realloc(ps->_a, ps->_capacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("Stackcapacity()::realloc()");
			return;
		}
		ps->_a = tmp;
	}
}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	Stackcapacity(ps);//动态申请
	ps->_a[ps->_top] = data;
	ps->_top++;
}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	if (ps->_top == 0)
	{
		printf("栈已空\n");
		return;
	}
	ps->_top--;
}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->_top != 0);
	return ps->_a[ps->_top - 1];
}

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

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	if (ps->_top == 0)
		return 1;
	else
		return 0;
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}

2.3 链式堆栈

2.3.1 Stack.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include "vld.h"

typedef int DataType;
typedef struct snode
{
	DataType data;
	struct snode* next;
}LSNode;

void StackInitiate(LSNode** head);//初始化

int StackNotEmpty(LSNode* head);//非空，返回1，否则返回0

void StackPush(LSNode* head, DataType x);//入栈

int StackPop(LSNode* head, DataType* x);//出栈，成功，返回1，否则，返回0

int StackTop(LSNode* head, DataType* x);//取栈顶元素，成功，返回1，否则，返回0

void Destroy(LSNode** head);//撤销栈
2.3.2 Stack.c
#include "LinStack.h"

void StackInitiate(LSNode** head)//初始化
{
	*head = (LSNode*)malloc(sizeof(LSNode));
	if (*head == NULL)
	{
		perror("StackInitiate():: malloc()");
		return;
	}
	(*head)->next = NULL;
}

int StackNotEmpty(LSNode* head)//非空，返回1，否则返回0
{
	if (head->next == NULL)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}

void StackPush(LSNode* head, DataType x)//入栈 
{
	LSNode* s = (LSNode*)malloc(sizeof(LSNode));
	if (s == NULL)
	{
		perror("StackPush():: malloc()");
		return;
	}
	s->data = x;
	s->next = head->next;
	head->next = s;
}

int StackPop(LSNode* head, DataType* x)//出栈，成功，返回1，否则，返回0
{
	if (!StackNotEmpty(head))
	{
		printf("栈已空！\n");
		return 0;
	}
	else
	{
		LSNode* del = head->next;
		*x = del->data;
		head->next = head->next->next;
		free(del);
		del = NULL;
		return 1;
	}
}

int StackTop(LSNode* head, DataType* x)//取栈顶元素，成功，返回1，否则，返回0
{
	if (!StackNotEmpty(head))
	{
		printf("栈已空！\n");
		return 0;
	}
	else
	{
		*x = head->next->data;
		return 1;
	}
}

void Destroy(LSNode** head)//撤销栈
{
	/*LSNode* p = *head;
	LSNode* del;
	while( p != NULL)
	{
		del = p;
		p = p->next;
		free(del);
	}
	del = NULL;*/
	while (StackNotEmpty(*head))
	{
		LSNode* del = *head;
		*head = (*head)->next;
		free(del);
	}
	free(*head);
	*head = NULL;
}

队列

1、队列的概念及结构

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

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

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

2、队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为在数组头上出数据效率比较低。

2.1 链式队列(rear初始化为NULL，之后指向队尾元素)

2.1.1 Queue.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int QDataType;
// 链式结构：表示队列 
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}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);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);
2.1.2 Queue.c
#include "Queue.h"

// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	q->_front = q->_rear = NULL;
	q->size = 0;
}

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
	if (tmp == NULL)
	{
		perror("QueueNode()::malloc()");
		return;
	}
	tmp->_next = NULL;
	tmp->_data = data;
	if (q->size == 0)
	{
		q->_front = q->_rear = tmp;
	}
	else
	{
		q->_rear->_next = tmp;
		q->_rear = tmp;
	}
	q->size++;
}

// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	if (q->size == 0)
	{
		printf("队列已空\n");
		return;
	}
	QNode* del = q->_front;
	q->_front = q->_front->_next;
	if (q->_front == NULL)
	{
		q->_rear = NULL;
	}
	free(del);
	del = NULL;
	q->size--;
}

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(q->_front);
	return q->_front->_data;
}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(q->_rear);
	return q->_rear->_data;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	return q->size;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	if (q->size == 0)
		return 1;
	else
		return 0;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	while (q->_front)
	{
		QNode* del = q->_front;
		q->_front = q->_front->_next;
		free(del);
	}
	q->_rear = NULL;
	q->size = 0;
}

2.2 顺序循环队列(rear初始化为0，指向待插入元素的位置)

2.2.1 Queue.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#define MaxQueueSize 6

typedef char DataType;
typedef struct
{
	DataType queue[MaxQueueSize];
	int front;
	int rear;
	int count;
}SeqCQueue,*pSeqCQueue;

void QueueInitiate(pSeqCQueue pmyQueue);//初始化队列

int QueueNotEmpty(SeqCQueue myQueue);//队列非空返回1，否则返回0

int QueueAppend(pSeqCQueue pmyQueue,DataType x);//入列，成功返回1，否则返回0

int QueueDelete(pSeqCQueue pmyQueue, DataType* x);//出列，成功返回1，否则返回0

int QueueGet(SeqCQueue myQueue, DataType* y);//取队头元素，成功返回1，否则返回0
2.2.2 Queue.c
#include "Queue.h"

void QueueInitiate(pSeqCQueue pmyQueue)//初始化队列
{
	pmyQueue->front = 0;
	pmyQueue->rear = 0;
	pmyQueue->count = 0;
}

int QueueNotEmpty(SeqCQueue myQueue)//队列非空返回1，否则返回0
{
	if (myQueue.count == 0)
		return 0;
	else
		return 1;
}

int QueueAppend(pSeqCQueue pmyQueue,DataType x)//入列，成功返回1，否则返回0
{
	if (pmyQueue->count == MaxQueueSize)
	{
		printf("队列已满！\n");
		return 0;
	}
	else
	{
		pmyQueue->queue[pmyQueue->rear] = x;
		pmyQueue->rear = (pmyQueue->rear + 1) % MaxQueueSize;
		pmyQueue->count++;
		return 1;
	}
}

int QueueDelete(pSeqCQueue pmyQueue, DataType* x)//出列，成功返回1，否则返回0
{
	if (!QueueNotEmpty(*pmyQueue))
	{
		printf("队列已空！\n");
		return 0;
	}
	else
	{
		*x = pmyQueue->queue[pmyQueue->front];
		pmyQueue->front = (pmyQueue->front + 1) % MaxQueueSize;
		pmyQueue->count--;
		return 1;
	}
}

int QueueGet(SeqCQueue myQueue, DataType* y)//取队头元素，成功返回1，否则返回0
{
	if (!QueueNotEmpty(myQueue))
	{
		printf("队列已空！\n");
		return 0;
	}
	else
	{
		*y = myQueue.queue[myQueue.front];
		return 1;
	}
}

Tips：

1、栈(一般实现顺序栈)

1.1 n个元素 依次进栈出栈的情况有多少种?

1.2 无论多简单都要写成一个函数，规范，不容易出错，如：stack.arr[top]，在main函数里，不一定是栈顶元素，因为不知道top是哪种指向

1.3 在实现括号匹配时，注意  栈是后进先出 且可以边进边出，然后注意多种情况

2、队列(一般实现链式队列)

2.1 在实现循环队列时，注意  怎么循环(%)，返回队尾元素小心越界

Lzc_217
关注
专栏目录
数据结构栈和队列试题及答案
11-26
队列和栈都是运算受限的线性表，只允许在表的一端进行特定的插入和删除操作，该说法正确。 18. **栈和队列的基本属性** 栈和队列都是线性表，但它们分别采用了LIFO和FIFO的规则来约束插入和删除操作，该说法正确...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
【数据结构】栈和队列
小羊的博客
07-12 2653
栈超超超详解
C语言-栈和队列
m0_73605503的博客
07-22 1336
欢迎来到HanLop博客的C语言数据结构初阶系列。在之前的文章中，我们详细介绍了链表及其操作方法。在本篇文章中，我们将深入探讨栈和队列这两种常见的数据结构。栈和队列虽然都是线性数据结构，但它们在数据的存取方式上有着显著的区别。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。通过理解和掌握这两种数据结构，您将能更有效地管理数据，并为后续更复杂的数据结构和算法的学习打下坚实的基础。让我们一起开始探
【数据结构】栈和队列超详细讲解
Become Mad的博客
05-27 2241
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
栈和队列的转化
xiaobai230811的博客
12-17 1250
栈与队列的相互转换栈和队列是两种基本的数据结构，它们在许多算法和程序中都有应用。虽然栈和队列在概念上是完全不同的，但是我们可以使用两个栈来实现一个队列，或者使用两个队列来实现一个栈。这种转换在某些情况下可能非常有用，例如，当我们的编程环境只提供了栈或队列的实现，但我们需要使用另一种数据结构时。在这篇博客中，我们将详细介绍如何使用两个栈来实现一个队列，以及如何使用两个队列来实现一个栈。我们将提供详细的代码示例，并解释每个函数的工作原理。提示：以下是本篇文章正文内容，下面案例可供参考。
JavaScript栈和队列
qq_44741577的博客
01-31 985
栈是一种特殊的线性表，仅能在线性表的一端操作，栈顶允许操作，栈底不允许操作。**栈的特点是：**先进后出，或者说是后进先出，从栈顶放入元素的操作叫入栈，取出元素叫出栈。栈的受限性体现在只允许在栈顶插入和删除，因此出栈和入栈都是在栈顶。
栈和队列的概念
stormsunshine的博客
04-14 4275
文章目录栈、队列和双端队列栈队列双端队列Java 中的栈、队列和双端队列单调栈和单调队列二叉堆和优先队列二叉堆优先队列 栈、队列和双端队列 栈和队列是常见的数据结构。栈的特点是后进先出，添加元素、删除元素和查看元素都在栈顶操作。队列的特点是先进先出，添加元素在队尾操作，删除元素和查看元素在队首操作。 双端队列比栈和队列更加灵活，可以在双端队列的两端添加元素、删除元素和查看元素。 栈、队列和双端队列都满足每次添加元素、删除元素和查看元素的时间复杂度是 O(1)O(1)O(1)。 栈、队列和双端队列都可以基于数
数据结构与算法——栈和队列
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
栈和队列原理
qq_43697646的博客
01-24 790
栈和队列是STL库里面的两个数据结构。STL有多个版本，知道STL的具体版本才能知道对应的栈和队列的实现原理。 三个常见的STL版本： （1）HP STL HP STL是C++ STL的第一个实现版本，而且开放源代码，其他版本的C++ STL一般是以HP STL为蓝本实现的。 （2）P.J.Plauger STL 由P.J.Plauger参照HP STL实现，被被Visual C++编译器所采用，不是开源的。 （3）SGI STL 由Silicon Graphics Computer Syst
栈和队列的基本操作
黄超的博客
04-04 2073
栈和队列的基本概念和操作
C语言中栈和队列实现表达式求值的实例
08-29
C语言中栈和队列实现表达式求值的实例 栈和队列是数据结构中两个非常重要的概念，它们在计算机科学和编程语言中有着广泛的应用。栈和队列可以用来实现表达式求值，下面我们将通过C语言来实现栈和队列实现表达式求值...
Python实现栈和队列的简单操作方法示例
09-18
本篇文章将深入探讨Python中如何实现栈（Stack）和队列（Queue）这两种基础数据结构。 栈是一种后进先出（Last In, First Out, LIFO）的数据结构，常用于临时存储和快速访问数据。在Python中，由于列表（List）的...
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
数据结构 —— 链式二叉树（C语言讲解）
知其然 知其所以然
10-17 744
本篇文章主要讲解链式存储的二叉树，如果读者不清楚二叉树的基础知识，推荐阅读数据结构——树和二叉树简介。对于二叉树这种数据结构的学习，重点不是增删改查，而是学习这种结构，所以，主要讲解一些链式二叉树的操作。
三维重建-基于Matlab实现结构光三维重建算法-优质项目分享.zip
最新发布
10-17
三维重建_基于Matlab实现结构光三维重建算法_优质项目分享
云网络验证系统云验证+卡密生成+多应用多用户管理
10-17
云网络验证系统云验证，多样化应用管理方式，多种项目任你开发，分布式应用开关，让您的应用开发更简单，本系统借鉴于易如意API写法及思路，完美实现多用户多应用管理。 源码特色 1，对接：详细的API文档，各种语言对接示例让您的接入更加简单 2，安全：客户端与服务器双向效验，动态数据加密，让您的数据“动起来” 3，API：各种API尽情对接，让您的应用大放光彩 4，快捷：后台一键式开关，应用版本，远程更新，更新内容等，让您更快捷更省心 5，功能：丰富的功能，各类数据统计，人性化的体验，满足您的更多需求 6，其他：内置商城、聊天室、工单等，我们将致力于给您最好的体验，如有任何问题都可以向我们反馈 支持多应用卡密生成 卡密生成 单码卡密 次数卡密 会员卡密 积分卡密 卡密管理 卡密长度 卡密封禁 批量生成 批量导出 自定义卡密前缀等 支持多应用多用户管理 应用备注 应用版本 多级代理价格 免费付费切换 验证用户IP 验证用户设备 应用开关等
毕业设计论文SpringBoot社区待就业人员信息管理系统.docx
10-17
毕业设计论文
栈和队列操作实现
"该资源是关于栈和队列的数据结构练习，包含C语言实现的代码，涉及栈的入栈、出栈以及队列的入队、出队等基本操作。" 在计算机科学中，栈（Stack）和队列（Queue）是两种基本的数据结构，它们在处理数据时遵循特定...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Lzc_217

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

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

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

打赏作者

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

抵扣说明：

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

余额充值