数据结构-栈与队列

最新推荐文章于 2026-06-20 18:32:07 发布
原创 最新推荐文章于 2026-06-20 18:32:07 发布 · 559 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #c++ #c语言

栈与队列

栈的定义：

栈是限定在表尾进行插入和删除的线性表，表尾具有特殊的意义，表尾叫做栈顶，表头叫做栈底，具有后进先出的特点，其称之为LIFO结构（last in first out），从逻辑结构上看，与线性表相同，为一对一的关系，存储结构用顺序栈或链栈存储既可，但是以顺序栈最为常见

队列的定义：

队列是一种先进先出的线性结构（first in firt out），允许插入的一头为队尾，允许删除的一头为队头

栈的基本操作：
定义文件
#pragma once
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define OK 1
#define ERROR -1

typedef struct SqStack{
	int* base;
	int* top;
	int stacksize;					//当前已经分配的栈的空间
}SqStack;


int InitStack(SqStack& S);		//成功返回OK,失败返回ERROR
int DestroyStack(SqStack& S);	//销毁成功返回OK，失败返回ERROR
int ClearStack(SqStack& S);		//清空栈中的所有元素
bool StackEmpty(SqStack& S);	//判断是否为空栈
int StackLength(SqStack& S);	//返回栈的个数
int Push(SqStack& S, int e);	//压栈
int Pop(SqStack& S, int& e);	//弹栈
int GetTop(SqStack& S, int& e);	//得到栈顶


#include <stdio.h>
#include <stdlib.h>
#include "structure.h"


int main() {
	SqStack S;
	
	InitStack(S);
	Push(S, 1);
	Push(S, 5);
	Push(S, 7);
	int len = StackLength(S);
	printf("%d\n", len);
	int e;
	Pop(S, e);
	printf("%d\n", e);
	GetTop(S, e);
	printf("%d\n", e);
	return 0;
}


int InitStack(SqStack& S) {
	S.base = (int*)malloc(sizeof(int) * STACK_INIT_SIZE);
	if (!S.base)
		return ERROR;
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;
	return OK;
}


int DestroyStack(SqStack& S) {
	if (!S.base) {
		free(S.base);			//释放指针指向的空间
		S.stacksize = 0;		//将栈的长度设置为0
		S.base = S.top = NULL;	//防止野指针的产生
	}
	
	return OK;
}


int ClearStack(SqStack& S) {
	if (S.base) {
		S.top = S.base;			//恢复初始化的状态
	}
	return OK;
}

bool StackEmpty(SqStack& S) {
	if (S.base) {
		if (S.base == S.top) {
			return true;
		}
		return false;
	}
}


int StackLength(SqStack& S) {
	/*
	* 思路：头指针减去尾指针的个数就是栈的个数
	*/
	if (S.base) {
		return S.top - S.base;
	}
	return ERROR;
}

int Push(SqStack& S, int e) {
	/*
	* 压栈操作：
	* 1.判断栈是不是为满
	* 2.如果为满重新分配内存（增加内存）
	* 3.如果不为满则将S.top指向的空间的值设置为e，并且S.top++
	*/
	if (S.base) {
		//栈满的情况
		if (S.top - S.base >= S.stacksize) {
			S.base = (int*)realloc(S.base,sizeof(int) * (S.stacksize + STACKINCREMENT));
			if (!S.base)
				return ERROR;
			S.top = S.base + S.stacksize;
			S.stacksize += STACKINCREMENT;
		}
		
		*S.top++ = e;
		return OK;
	}
}

int Pop(SqStack& S, int& e) {
	/*
	* 1.首先判断栈是否为空，如果为空，返回ERROR
	* 2.如果不为空，top--，e = *top 
	*/

	if (S.base) {
		if (S.base == S.top)
			return ERROR;
		e = *(--S.top);
	}
	return OK;
}


int GetTop(SqStack& S, int& e) {
	if (S.top == S.base)
		return ERROR;
	e = *(S.top - 1);
	return OK;
}
栈的应用：
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include "structure.h"


int main() {

	SqStack OPTR, OPND;				//OPTR为运算符栈，OPND为操作数栈
	InitStack(OPTR);
	InitStack(OPND);
	char sum = EvaluateExpression(OPTR,OPND);
	
	printf("%d", sum);
	return 0;
}



int InitStack(SqStack& S) {
	S.base = (char*)malloc(sizeof(char) * STACK_INIT_SIZE);
	if (!S.base)
		return ERROR;
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;
	return OK;
}

int Push(SqStack& S, char c) {
	if (S.base) {
		if (S.top - S.base >= S.stacksize) {
			S.base = (char*)realloc(S.base, sizeof(char) * (S.stacksize * STACKINCREAMENT));
			if (!S.base)
				return ERROR;
			S.top = S.base + S.stacksize;
			S.stacksize += STACKINCREAMENT;
		}
		*S.top++ = c;
		return OK;
	}
	return ERROR;
}

int Pop(SqStack& S, char& c) {
	if (S.base) {
		if (S.base == S.top)
			return ERROR;
		else {
			c = *(--S.top);
			return OK;
		}
	}
	return ERROR;
}

char GetTop(SqStack& S) {
	if (S.base) {
		if (S.base == S.top)
			return NULL;
		return *(S.top - 1);
	}
	return NULL;
}

int EvaluateExpression(SqStack& OPTR, SqStack& OPND) {
	char c;
	char x;				//弹出相同等级的操作符
	Push(OPTR, '#');
	c = getchar();			//获取缓存区的第一个字符
	while (c != '#' || GetTop(OPTR) != '#') {
		if (!IN(c))				//如果不是操作符将其压入操作数栈
		{
			Push(OPND, c);
			c = getchar();		//继续从缓存区中取数据
		}
		else 
			switch (Precede(GetTop(OPTR), c)) {
			case '<':
				//栈顶元素的优先级低压栈
				Push(OPTR, c);
				c = getchar();
				break;
			case '=':
				//去除括号
				Pop(OPTR, x);
				c = getchar();
				break;
			case '>':
				//弹出操作符号
				char theta, b, a;
				Pop(OPTR, theta);
				Pop(OPND, a);
				Pop(OPND, b);
				Push(OPND, operate(a, theta, b));
				break;
			default:
				break;
			}
	}
	return GetTop(OPND);
}


bool IN(char c) {
	for (int i = 0; i < 7; i++) {
		if (c == allOperator[i])
			return true;
	}
	return false;
}

char Precede(char c1, char c2) {

	//获得c1，c2的优先级等级
	int c1Prior = getPriorNum(c1);
	int c2Prior = getPriorNum(c2);
	if (c1Prior > c2Prior)
		return '>';
	else if (c1Prior == c2Prior)
		return '=';
	else
		return '<';
}


int getPriorNum(char c) {
	int priorNum;
	switch (c)
	{
	case '#':
		priorNum = -1;
		break;
	case '(':
		priorNum = 0;
		break;
	case '+':
		priorNum = 1;
		break;
	case '-':
		priorNum = 1;
		break;
	case ')':
		priorNum = 2;
		break;
	case '/':
		priorNum = 2;
		break;
	case '*':
		priorNum = 3;
		break;
		
	default:
		break;
	}
	return priorNum;
}

char operate(char a, char t, char b) {
	int sum;
	int	c = a - '0';
	int d = b - '0';			//将char转化为int

	switch (t)
	{
	case '+': sum = c + d; break;
	case '-': sum = c - d; break;
	case '*': sum = c * d; break;
	default: sum = c / d;
	}
	char strSum = sum + '0';			//将int转化为char
	
	return sum;
}
数据类型定义：
#pragma once
#define STACK_INIT_SIZE 100
#define STACKINCREAMENT 10
#define OK 1
#define ERROR -1


typedef struct SqStack{
	char* top;
	char* base;
	int stacksize;			//堆栈的大小
}SqStack;

char allOperator[] = { '+' , '-' , '*' , '/' ,'(' , ')' , '#' }; //把符号转换成字符数组 


int InitStack(SqStack& S);					//初始化栈
int Push(SqStack& S,char c);				//压栈
int Pop(SqStack& S, char& c);				//出栈
char GetTop(SqStack& S);						//得到栈顶的元素
/*
* 比较操作符的优先级
*/
char Precede(char c1, char c2);					
int getPriorNum(char c);			//获得优先级等级操作符
char operate(char a, char t, char b);
bool IN(char c);
int EvaluateExpression(SqStack& OPTR, SqStack& OPND);

链式队列

结构体的定义
#pragma once
//定义队列的链式存储结构

//结点的定义
typedef struct QNode {
	int data;			//data数据域
	struct QNode* next;
}QNode,*QueuePtr;


//首尾指针的定义
typedef struct {
	QueuePtr front;			//队头指针
	QueuePtr rear;			//队尾指针
}LinkQueue;


void InitQueue(LinkQueue& Q);			//队列的初始化
void EnQueue(LinkQueue& Q,int data);	//向队列中插入一个元素
void DuQueue(LinkQueue& Q, int& data);	//删除队列的头部元素
void DestroyQueue(LinkQueue& Q);		//销毁队列
void DisplayQueue(LinkQueue& Q);		//展现队列中所有元素
方法的实现
#include <stdio.h>
#include <stdlib.h>
#include "structure.h"


int main() {


	LinkQueue Q;
	int a;
	InitQueue(Q);
	EnQueue(Q, 1);
	EnQueue(Q, 2);
	EnQueue(Q, 3);
	DisplayQueue(Q);
	DuQueue(Q, a);

	printf("%d", a);
	return 0;
}


void InitQueue(LinkQueue& Q) {
	
	Q.front = Q.rear = (QNode*)malloc(sizeof(QNode));		//创建首元结点，并将首尾指针指向首尾结点
	if (!Q.front)
		exit(-1);
	Q.front->next = NULL;							//将第一个结点的指针域置为空
}


void EnQueue(LinkQueue& Q, int data) {
	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
	p->data = data;					//给数据域进行赋值
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;						//将队尾指针指向最后一个结点
}

void DuQueue(LinkQueue& Q, int& data) {
	if (Q.front == Q.rear)
		exit(-1);				//如果队列是空队列，则无法弹出，报错
	QueuePtr p = Q.front->next;
	data = p->data;
	Q.front->next = p->next;			//将首指针指向删除结点的下一个结点
	if (Q.rear == p)
		Q.rear = Q.front;
	free(p);
	
}

void DestroyQueue(LinkQueue& Q) {
	//销毁队列Q
	while (Q.front)
	{
		Q.rear = Q.front->next;
		free(Q.front);
		Q.front = Q.rear;
	}
}


void DisplayQueue(LinkQueue& Q) {
	if (Q.rear == Q.front)
		exit(-1);
	QueuePtr p = Q.front->next;
	while (Q.rear->next != p)
	{
		printf("%d\n", p->data);
		p = p->next;	
	}
}
数据结构 栈和队列常见算法问题
qq_43128902的博客
10-13 1160
数据结构，栈和队列常见算法 算法和问题来自于试卷，辅导书，以及网络。 // 数据结构 typedef struct { int data[Maxsize]; int top; }Sqstack; ```//顺序栈 typedef struct { int data[Maxsize]; int front,rear; }Squeue; 算法3.1.1 假设I,O分别表示入栈和出栈操作。栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由I和O组成的序列，可操作的序列称为合
C/C++相关概念和易错知识点（16）（链表、栈和队列、循环队列）
SGlow0708的博客
03-03 1129
（指针的指针），而后续的接口就不需要二级指针，因为访问后续的结点只需要找到第一个节点即可，第一个节点可以通过new1存储的值找到，所以拿到new1的值就可以对后续结点实行操作，传值即可。在主函数中创建了new这个结构体，里面包含了两个指针和一个整型变量，其中那两个指针是野指针，需要被处理，这个时候初始化直接传结构体指针，将里面的值改为0和NULL。使用这种方式的话，我们在栈区创建的是一个指针，但此时这个指针相当于野指针，不能使用，要让它指向一片ListNode的空间，这个空间会在堆上开辟。
前端学习笔记
求知若饥，谦卑若愚
05-19 556
百度笔试题 1、关于链表的说法错误的是：
如果你用c++的栈或队列发生了报错~
H13420972436的博客
03-30 510
0. s.top()或q.front()前先排除s,empty()或q.empty()的情况，不然就会导致“栈溢出”特别气人的是：报错信息根本不清楚，devcpp中甚至报错位置都不对，在一开头创建栈的时候就崩溃了，我还以为语法有问题呢。实际上：真正的错误在后头的栈的操作中，我一开始在s.top(即访问栈顶)前没有排除栈为空的情况（s.empty()）。类似的，对于链表，访问链表的值之前，先要排除其为空的情况（node == NULL）1. s.pop()前也是如此。
栈（Stack）顺序栈以及链栈的相关操作（C语言）
派拉斯兔子的博客
05-07 1566
<img src='https://img-blog.csdnimg.cn/2021050719043789.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDk2Njcw,size_16,color_FFFFFF'>
数据结构与算法——栈和队列
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
[详解栈和队列]数据结构之栈与队列
Philosophy7的博客
05-12 4167
✅作者简介：大家好,我是Philosophy7？让我们一起共同进步吧！🏆 📃个人主页：Philosophy7的csdn博客 🔥系列专栏： 👑哲学语录: 承认自己的无知，乃是开启智慧的大门 💖如果觉得博主的文章还不错的话，请点赞👍+收藏⭐️+留言📝支持一下博>主哦🤞 文章目录栈和队列1.物理结构和逻辑结构2.什么是栈2.1栈的基本操作3.什么是队列队列的基本操作小结 栈和队列 1.物理结构和逻辑结构 再了解栈和队列之前，我们要先知道什么是逻辑结构和物理结构。 逻辑结构: 按照逻辑结构划分:数据结.
【数据结构】栈和队列
2301_81348661的博客
12-08 3738
然后，我们可以使用STTop取出栈(st)中的数据，进行对栈(s)的左右括号的匹配，如果匹配不成功，则返回false，直到栈(s)为空时，过程结束。若节点大于一个，那我们可以创建一个QNode*的next节点指向队头指向的下一个节点，然后再将队头的节点free，再重新将队头的节点改为next指针指向的新节点。首先，我们来了解一种新的数据结构——栈。将数据导入栈中，首先，将空间进行扩容（防止空间不足引起的越界访问）,并将扩容后的空间传给数组a，然后，再于新空间进行导入数据的操作，结尾记得改变新栈的个数。
【数据结构】栈与队列
做梦都想要三十万年薪~
10-04 2173
栈与队列~
数据结构——栈和队列
fax_player的博客
09-27 6203
本文详细介绍的栈和队列的实现方式，更是重点提到了4个关于栈和队列的OJ题：分别是设计循环队列，用栈实现队列，用队列实现栈，有效的括号。
栈（学习笔记）
qq_43986343的博客
08-02 671
栈的学习笔记
* & 的问题 （待整理）
weixin_30545285的博客
04-22 767
资料：http://tieba.baidu.com/f?kz=1053435983 void InitStack( SqStack *&S) 浏览次数：3426次悬赏分：5|解决时间：2006-8-12 00:19|提问者：dangdangxww 为什么这个S形参前面用了* 和&呢？是怎么个用法，含义如何呀？ 小弟在这先谢了，那位高手...
表达式求解问题（运用栈）
DX奥特曼的博客
01-03 5645
问题描述] 表达式求解是实现程序设计的基本问题之一，也是栈的应用的一个典型例子。设计一个程序用算符优先法求解表达式的值。 [基本要求] 以字符序列的形式从键盘输入语法正确的、不含变量的整数表达式，利用教科书表3.1给出的算符优先关系，实现对算术四则混合运算表达式的求值，并仿照教科书的例3-1演示在求值过程中运算符栈、运算数栈、输入字符和主要操作的变化过程。 [实现提示] （1）设置运...
Python 优雅解析 Excel：从原生行列到强类型对象的三层数据结构演进
asdzx67的博客
06-15 332
对于数据结构固定、业务逻辑复杂的 Excel 场景，字典结构的弱类型特性会带来类型混乱、无代码提示、无法封装业务逻辑等问题。定义业务实体类，将每行 Excel 数据映射为实体对象，实现强类型约束、自动代码补全、自定义数据校验和业务方法封装。从「二维列表数字索引」到「字典语义取值」，再到「自定义对象强类型封装」，三层数据结构的迭代，本质是代码从「机器思维」向「业务思维」的升级。简单场景无需过度设计，通用场景优先字典列表，工程化复杂场景首选自定义实体对象。
算法与数据结构之Floyd算法
最新发布
weixin_73953650的博客
06-20 319
超详细的Floyd算法教程，一看就懂！
多线程编程（一）
m0_62591054的博客
06-16 209
编译时：需加上 -lpthread，链接上对应的线程支持库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值