栈和队列相关题目

最新推荐文章于 2025-07-08 19:52:11 发布
最新推荐文章于 2025-07-08 19:52:11 发布
阅读量1.7w 收藏 7
点赞数 5
CC 4.0 BY-SA版权
文章标签： 数组实现共享栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_38032942/article/details/81779152
这篇博客讨论了如何使用栈和队列解决多种问题。首先介绍了如何设计一个支持Push、Pop和返回最小值的栈，利用两个栈实现这一目标。接着，通过数组实现两个共享栈，利用奇偶位置存放不同栈的元素。然后，探讨了检查元素出栈和入栈顺序合法性的方法。此外，还展示了如何使用两个栈实现一个队列，以及如何用两个队列实现一个栈的思路。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题目一：实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1)
本题目的GitHub地址

  • 本题目的实现思路比较简单，使用两个栈，一个栈是用来存储数字，就是普通的数据，在代码中这个栈为Stack

  • 结构体的设计：数字+出现次数，另一个栈便用来存储结构体，在代码中这个栈为NumStack，这个栈的栈顶永远存的是Stack栈中的最小值和最小值个数构成的结构体

  • 所以我们将要设计的这个栈命名为DoubleStack，提供入栈，出栈，返回最小值得接口和其它基本接口

  • 入栈：首先我们先考虑入栈，入栈的时候呢，对于Stack肯定是必须要入栈的，对于NumStack的话就需要考虑了，如果NumStack是空栈，那么肯定是第一次进入元素，所以两个栈都要存东西，而且对于第一次存入的应该将最小值对应的结构体设置为1

  • 如果NumStack 栈不为空的话，那么在压栈之前就需要比较大小，如果比NumStack 栈栈顶元素还小的话就需要将这个较小值压栈，如果相等的话就对栈顶元素的结构体的num+1即可！

  • 出栈：首先还是先要获取栈顶元素，因为不是每一次入Stack 栈的元素都能存入到NumStack 中，所以要出栈的元素和NumStack 的栈顶相等的话就将对应的结构体的count属性-1，要是count原本就是1，那么直接将此元素在NumSatck 中出栈即可！

  • 上一步只是判断NumStack 中的元素是否需要出栈，但是将Stack 中的元素出栈是必要的，所以最后将Stack 中的元素弹栈！

GIF演示过程——入栈
这里写图片描述
GIF演示过程——出栈
这里写图片描述

void DoubleStackPush(DoubleStack* ds, IDataType x)
{
	SDataType s;
	SDataType ret;
	assert(ds);

	//如果结构体栈为空
	if(NStackEmpty(&ds->nst) == 0)
	{
		s.count = 1;
		s.num = x;
		StackPush(&ds->st,x);
		NStackPush(&ds->nst, s);
	}
	else
	{	
		StackPush(&ds->st, x);
		//如果入栈的元素小于最小值记录栈的栈顶
		if(x < NStackTop(&ds->nst).num)
		{
			s.num = x;
			s.count = 1;
			//将此元素的对应结构体入栈
			NStackPush(&ds->nst, s);
		}
		else if (x == NStackTop(&ds->nst).num) 
		{
			//相等的情况
			ret = NStackTop(&ds->nst);
			NStackPop(&ds->nst);
			ret.count += 1;
			NStackPush(&ds->nst, ret);
		}
	}
}
void DoubleStackPop(DoubleStack* ds)
{
	SDataType ret;
	assert(ds);
	//先获取结构体栈的栈顶元素
	ret = NStackTop(&ds->nst);

	//如果像个相等就做结构体计数-1或者出栈操作
	if(ret.num == StackTop(&ds->st))
	{
		if(ret.count == 1)
		{
			NStackPop(&ds->nst);
		}
		else 
		{
			ret.count--;
			NStackPop(&ds->nst);
			NStackPush(&ds->nst, ret);
		}
	}
	//将原本存数字出栈
	StackPop(&ds->st);
}

题目二：一个数组实现两个栈(共享栈)

本题需要使用一个数组来完成两个栈，于是最容易实现这两个栈的方法就是奇偶栈！
数组中的奇数位用来存储一个栈的数据，偶数位用来存储另一个栈的数据！
这里写图片描述

#include "ShareStack.h"

void ShareStackInit(ShareStack* pss)
{
	assert(pss);
	pss->_top1 = 0;
	pss->_top2 = 1;
}

//which 1/2
void ShareStackPush(ShareStack* pss, SSDataType x, int which)
{
	assert(pss && (which == 1 || which == 2));
	if (pss->_top1 < N && pss->_top2 < N)
	{
		if (which == 1)
		{
			pss->_a[pss->_top1] = x;
			pss->_top1 += 2;
		}
		else
		{
			pss->_a[pss->_top2] = x;
			pss->_top2 += 2;
		}
	}
	else
		printf("空间不足\n");
}
void ShareStackPop(ShareStack* pss, int which)
{
	assert(pss && (which == 1 || which == 2));

	if (which == 1 && (pss->_top1 - 2 >= 0))
		pss->_top1 -= 2;
	else if (which == 2 && (pss->_top2 - 2 >= 0))
		pss->_top2 -= 2;
}
int error_flag = 0;
SSDataType ShareStackTop(ShareStack* pss, int which)
{
	assert(pss && (which == 1 || which == 2));

	if (which == 1 && pss->_top1-2 >= 0)
		return pss->_a[pss->_top1 -2];
	else if (which == 2 && pss->_top2- 2 >= 0)
		return pss->_a[pss->_top2 -2];
	error_flag = -1;
	return error_flag;
}

void TestShareStack()
{
	ShareStack ss;
	ShareStackInit(&ss);
	ShareStackPush(&ss,11, 1);
	ShareStackPush(&ss, 22, 1);
	ShareStackPush(&ss, 33, 2);
	ShareStackPush(&ss, 44, 1);

	printf("%d\n", ShareStackTop(&ss, 1));
	ShareStackPop(&ss, 1);

	printf("%d\n", ShareStackTop(&ss, 1));
	ShareStackPop(&ss, 1);

	printf("%d\n",ShareStackTop(&ss, 2));
	ShareStackPop(&ss, 2);
}

题目三：元素出栈、入栈顺序的合法性。如入栈的序列(1,2,3,4,5)，出栈序列为 (4,5,3,2,1) 。

这个问题需要将in 数组不停的入栈将每个入栈的元素与out 比较，相同的就出栈，否则继续入栈，然后直到in 数组已经没有元素可以入栈，接着就是逐个比较剩下的元素，每一个元素都要匹配才可以认定是匹配的！如下图：
这里写图片描述

#include "Stack.h"

int IsLegal(int *in, int *out, int insize, int outsize)
{
	int i = 0;
	int j = 0;
	Stack st;
	//如果指针无效或者长度不一样是无法判断的
	assert(in && out && insize == outsize);
	StackInit(&st);
	//将in数组中的元素压入栈中逐个比较，如果栈顶元素与out数组中的一致就弹出此元素
	while(i<insize)
	{
		StackPush(&st, in[i++]);
		if (StackTop(&st) == out[j]) {
			StackPop(&st);
			j++; //注意out数组中比较过的元素要跳过，所以下标要+1
		}
	}

	//此时栈中剩下的元素要与out数组中剩下的元素逐个比较，遇到不一样的就不匹配
	while (StackEmpty(&st) != 0)
	{
		if(StackTop(&st) != out[j++])
		{
			return 0;
		}
		StackPop(&st);
	}
	//此时为空栈，则说明匹配
	return 1;
}

int main(void)
{
	int in[5] = {1, 2, 3, 4, 5};
	int out[5] = {4, 5, 3, 2, 1 };
	int ret = IsLegal(in, out, 5, 5);
	if (ret == 1)
		printf("匹配\n");
	else
		printf("不匹配\n");

	system("pause");
	return 0;
}

测试用例：
入站数据：int in[5] = {1, 2, 3, 4, 5};
两组合法数据：
int out[5] = {4, 5, 3, 2, 1 };
int out[5] = {2, 3, 4, 5, 1 };
两组非法数据:
int out[5] = {4, 5, 3, 1, 2 };
int out[5] = {4, 3, 2, 5, 1 };

题目四：使用两个栈实现一个队列

  • 要实现Push接口其实不难，因为我们只需要向一个栈里面Push数据即可，我们暂且将这个栈定义为栈一，另一个栈设定为栈二
  • 要实现Pop接口的话，其实只要先判断栈二是否为空栈，如果栈二不为空那么直接Pop出一个元素即可，如果栈二不为空，那么需要先将栈一中的元素全部转移到栈二中，然后栈二就有元素了，直接Pop出一个即可！
#include "Topic.h"
void QueueByTwoStackInit(QueueByTwoStack* qts)
{
	assert(qts);
	StackInit(&(qts->s1));
	StackInit(&(qts->s2));
}

void QueueByTwoStackDestory(QueueByTwoStack* qts)
{
	assert(qts);
	StackDestory(&(qts->s1));
	StackDestory(&(qts->s2));
}

//永远向栈一Push元素
void QueueByTwoStackPush(QueueByTwoStack* qts, DataType x)
{
	assert(qts);
	StackPush(&(qts->s1),x);
}

void QueueByTwoStackPop(QueueByTwoStack* qts)
{
	assert(qts);
	//如果栈二为空需要先将栈一中的元素全部转移到栈二中
	if (StackEmpty(&(qts->s2)) == 0) 
	{
		while (StackEmpty(&(qts->s1)))
		{
			StackPush(&(qts->s2), StackTop(&(qts->s1)));
			StackPop(&(qts->s1));
		}
	}
	StackPop(&(qts->s2));
}

DataType QueueByTwoStackFront(QueueByTwoStack* qts)
{
	assert(qts);
	if (StackEmpty(&(qts->s2)) == 0)
	{
		while (StackEmpty(&(qts->s1)))
		{
			StackPush(&(qts->s2), StackTop(&(qts->s1)));
			StackPop(&(qts->s1));
		}
	}
	return StackTop(&(qts->s2));
}

int QueueByTwoStackSize(QueueByTwoStack* qts)
{
	assert(qts);
	return StackSize(&(qts->s1)) + StackSize(&(qts->s2));
}

int QueueByTwoStackEmpty(QueueByTwoStack* qts)
{
	assert(qts);
	return StackEmpty(&(qts->s1)) | StackEmpty(&(qts->s2));
}

void TestQueueByTwoStack()
{
	QueueByTwoStack qs;
	QueueByTwoStackInit(&qs);
	QueueByTwoStackPush(&qs, 11);
	QueueByTwoStackPush(&qs, 22);
	QueueByTwoStackPush(&qs, 33);
	QueueByTwoStackPush(&qs, 44);
	QueueByTwoStackPop(&qs);
	QueueByTwoStackPop(&qs);
	QueueByTwoStackPush(&qs, 55);

	QueueByTwoStackDestory(&qs);
}

这里写图片描述

题目五：使用两个队列实现一个栈

接下来是两个队列实现一个栈，首先先大致说一下怎么实现？
这里写图片描述
如图所示，两个队列总有一个是空队列，一个是非空队列，要入栈的话，必须要入非空队列，出栈的话，必须让非空队列将元素转移到空队列里面，直到非空队列剩余一个元素，然后将剩余的这一个元素出队列，即可完成“出栈”

#include "motive.h"

//初始化
void StackByTwoQueueInit(StackByTwoQueue* stq)
{
	assert(stq);
	QueueInit(&(stq->q1));
	QueueInit(&(stq->q2));
}

//销毁
void StackByTwoQueueDestory(StackByTwoQueue* stq)
{
	assert(stq);
	QueueDestory(&(stq->q1));
	QueueDestory(&(stq->q2));
}

//分配空队列与非空队列
static EmptyCmp(Queue** em, Queue** noem, StackByTwoQueue** pstq)
{
	assert(stq);
	QueueEmpty(&(*pstq)->q1) == 1 ? ((*noem = &(*pstq)->q1), *em = &((*pstq)->q2)) : ((*noem = &(*pstq)->q2), *em = &((*pstq)->q1));
}
//获取顶部数据
DataType StackByTwoQueueTop(StackByTwoQueue* stq)
{
	assert(stq);
	Queue *empty;
	Queue *noempty;
	DataType ret;
	//通过三元运算符确定空队列与非空队列
	EmptyCmp(&empty, &noempty, &stq);

	//将非空队列的元素转移到非空队列，保留一个
	while (QueueSize(noempty) > 1)
	{
		QueuePush(empty, QueueFront(noempty));
		QueuePop(noempty);
	}
	//获取保留结果数据
	ret = QueueFront(noempty);
	//将剩下的一个数据也转移
	QueuePop(noempty);
	QueuePush(empty, ret);
	return ret;
}

//判断模拟栈是否为空，为空返回0，不为空返回1
int StackByTwoQueueEmpty(const StackByTwoQueue* stq)
{
	assert(stq);
	//只要有一个队列不为空那么模拟栈就不为空
	return QueueEmpty(&(stq->q1)) | QueueEmpty(&(stq->q2));
}

//模拟栈中存入的元素个数
int StackByTwoQueueSize(const StackByTwoQueue* stq)
{
	assert(stq);
	return QueueSize(&(stq->q1)) + QueueSize(&(stq->q2));
}

//Push数据
void StackByTwoQueuePush(StackByTwoQueue* stq, DataType x)
{
	Queue *empty;
	Queue *noempty;
	assert(stq);
	EmptyCmp(&empty, &noempty, &stq);

	//永远向不为空的队列插入数据
	QueuePush(noempty,x);
}

//Pop数据
void StackByTwoQueuePop(StackByTwoQueue* stq)
{
	Queue *empty;
	Queue *noempty;
	assert(stq);
	EmptyCmp(&empty, &noempty, &stq);

	//与StackByTwoQueueTop()一样的过程，只是最后余下的元素直接出队列
	while (QueueSize(noempty) > 1)
	{
		QueuePush(empty, QueueFront(noempty));
		QueuePop(noempty);
	}
	printf("Pop:%d\n", noempty->_front->_data);
	QueuePop(noempty);
}

//测试函数
void TestStackByTwoQueue()
{
	StackByTwoQueue sq;
	StackByTwoQueueInit(&sq);
	StackByTwoQueuePush(&sq, 11);
	StackByTwoQueuePush(&sq, 22);
	StackByTwoQueuePush(&sq, 33);
	StackByTwoQueuePush(&sq, 44);
	StackByTwoQueuePop(&sq);
	StackByTwoQueuePop(&sq);
	StackByTwoQueuePush(&sq, 55);
	StackByTwoQueuePop(&sq);
	StackByTwoQueuePop(&sq);
	StackByTwoQueuePop(&sq);
	StackByTwoQueueDestory(&sq);
}
栈和队列题目合集
Jeloys的博客
03-19 1423
复习栈的知识，然后做了一下精选的几道LeetCode题目：20,155,232,844,224,682,496 栈的知识总结 什么是栈？ 1.后进者先出，先进者后出，这就是典型的“栈”结构。 2.从栈的操作特性来看，是一种“操作受限”的线性表，只允许在端插入和删除数据。 什么时候需要用到栈？ 当某个数据集合只涉及在某端插入和删除数据，且满足后进者先出，先进者后出的操作特性时，我们...
栈和队列习题整理
m0_49991895的博客
02-19 826
一、括号匹配问题 题目描述如下： 解题思路：使用栈来解决，扫描字符串，当碰到左括号时直接入栈，当扫描到右括号时，弹出栈顶元素查看是否匹配，不匹配直接false，否者重复上述流程。 两个边界问题： 扫描完字符串，栈不为空时，说明左括号多了，没有相匹配的右括号，直接false。 扫描到第一个右括号时，发现栈为空，说明右括号是该字符串的第一个字符，没有相匹配的左括号，直接false。 代码如下： public class Num20 { public boolean isValid...
栈和队列（数据结构学习笔记）
最新发布
2401_87777360的博客
07-08 921
栈（stack）是一个特殊的线性表，是限定仅在一端（通常是表尾）进行插入和删除的线性表。又称为后进先出（Last In First Out）的线性表,简称LIFO结构。栈是仅在表尾进行插入、删除的线性表。表尾（即an端）称为栈顶Top;表头（即a1端）称为栈底Base。插入元素到栈顶（即表尾）的操作，称为入栈。“入”=压入=PUSH(x)从栈顶（即表尾）删除最后一个元素的操作，称为出栈。“出”=弹出=POP(y)队列（queue）是一种。
栈和队列练习题
An_Mo的博客
07-04 723
一、有效的括号 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。 有效字符串需满足： 1、左括号必须用相同类型的右括号闭合。 2、左括号必须以正确的顺序闭合。 示例 1： 输入：s = “()” 输出：true 示例 2： 输入：s = “()[]{}” 输出：true 示例 3： 输入：s = “(]” 输出：false 示例 4： 输入：s = “([)]” 输出：false 示例 5： 输入：s = “{[]}” 输出：true 提示： 1 &lt
关于队列和栈的几道面试题
宇哲
09-18 2553
关于队列和栈的几道面试题今天来说几道简单的栈和队列相关的几道面试题：1 . 实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O (1 )第一道题，我们需要分析，我想一般的思维肯定是想到，开辟一块空间，进行保存最小值，这种方法也是大家通常地一下就可以想到的。但是在这里会有一个问题，就是如果你的最小值在栈顶，当你pop了栈顶以后，下面的数据中最小的元素就
栈和队列的常见面试题
snow_5288的博客
05-04 3886
1、两个队列实现一个栈 两个队列实现一个栈2、两个栈实现一个队列 【算法思想】 1>设计类 成员变量：给两个栈s1和s2来模拟实现一个队列 成员函数：入队Push()和出队Pop() 2>给两个指向栈对象s1、s2的指针input和output，分别用来入队和出队 3>按照先进先出的方式模拟入队和出队操作 Push：将input指向不空的栈，然后在input中入队 Pop：将inp
数据结构作业：第三章-栈和队列题目.docx
12-17
数据结构作业：第三章-栈和队列题目 本文档旨在提供一个详细的知识点总结，涵盖数据结构第三章中的栈和队列概念。通过对题目的逐一分析，我们将对栈和队列的基本概念、特点、操作和应用进行总结。 栈的基本概念 ...
【LeetCode刷题】栈和队列题目练习~
认真分享博客，认真分享学习
05-19 921
一个栈保持空队列，每次push就往里push，再把另一个栈顺序的队列的元素全部导到这个刚push一个的元素里。遍历tokens，是数字就按顺序存在容器里，遇到运算符，就取出最近插入的两个数字计算，注意前面的减后面的（减法和除法注意），然后再把计算结果返回到容器里。正常栈push进数据，再要pop或者返回top的时候，几把数据push到辅助栈里，然后辅助栈pop、top都可以。一个队列思路就是：一个元素进去，要保证它是在front位置，怎么保证，把前面的所有元素再一次push进队列就可以。
算法讲解014【入门】队列和栈入门题目-栈和队列相互实现.pptx
08-27
算法讲解014【入门】队列和栈入门题目-栈和队列相互实现
栈和队列的练习题
AlinaQ05的博客
08-04 1056
第一个栈 push 元素时，当另一个栈中没有元素时将当前插入的元素 push 进去，然后每一次插入元素时两个栈中的栈顶元素进行比较。如果当前插入的元素小于第二个栈的栈顶元素，就将当前元素 push 到第二个栈中，否则就将第二个栈中的栈顶元素重新入栈。处理括号问题，就是将括号中的部分看成一个整体，每次遇到左括号，将括号放入栈中，直到遇到右括号，再计算括号中的部分。所以就可以使用栈来完成，遇到左括号就将相应匹配的右括号加入栈中，后续如果是合法的，右括号的顺序就是栈中弹出的顺序。队列中的元素为int类型。....
【数据结构】--几道栈和队列面试题
海绵宝宝的欧尼~ 的博客
05-05 1368
用两个栈实现一个队列 1、思路分析 拿到这道题，会有以下几种思路： 思路一：入队时，将所有的元素压入到s1中 出队时，将s1中的所有元素倒入到s2中，然后让s2中栈顶的元素出栈，然后将s2中所有的元素倒入到s1中问题所在：我们不难发现，在这种解法中，要进行来回倒栈，时间复杂度就会比较大，做起来也比较麻烦 思路二： 说明：是对第一种的优化我们不难发现，其实在进行倒栈的时候，没必要进行最后一个元
栈的应用练习题
09-29
栈的练习题目：括号匹配 数制转换 队列的练习题，队列
几个有关栈的题目
iDJ77的博客
01-25 7411
例题 设栈的顺序存储空间为S（1：50），初始状态为top=-1。现经过一系列正常的入栈与退栈操作后，top=30，则当前栈中的元素个数为（　D　）。 A.20 B.19 C.31 D.30 设栈的顺序存储空间为S（1：m），初始状态为top=m+1，则栈中的数据元素个数为（　B　）。 A.top-m+1 B.m-top+1 C.m-top D.top-m 设栈的顺序存储空间为S（1：50），初始状态为top=-1。现经过一系列正常的入栈与退栈操作后，top=30，则当前栈中的元素个数为（　B　）。 A.
算法：栈相关经典算法题目
hefrankeleyn的博客
10-17 866
栈相关题目 文章目录栈相关题目一、[20. 有效的括号](https://leetcode-cn.com/problems/valid-parentheses/)1.1 解法一： 使用Stack栈（FILO）来实现（可以使用双端队列代替）二、[155. 最小栈](https://leetcode-cn.com/problems/min-stack/)2.1 解法一：自定义栈2.2 解法二：使用辅助栈三、[84. 柱状图中最大的矩形](https://leetcode-cn.com/problems/larg
队列的练习题
m0_66483195的博客
12-13 706
队列练习笔记
算法竞赛入门经典例题-优先队列（阿格斯）
冗长的专栏
07-09 1071
优先队列例题： 阿格斯（Argus） 你的任务是编写一个称为Argus的系统。该系统是支持一个Register命令，Register Q_num Period 该命令注册了一个触发器，它每秒钟就会产生一次编号为Q_num的事件，你的任务是模拟出钱k个事件。如果多个事件同时发生，先处理Q_NUM小的事件#include<iostream> #include<queue> using namesp
【经典优先队列例题整理】
Nodies
07-27 2104
———————————————————————————————————————————————ITime Limit:2000MS Memory Limit:65536KB 64bit IO Format:%lld & %llu SubmitStatus Description 我们的小伙伴Bingo真的很调皮，他在上课的路上看到树上有个鸟窝，他就想去把他捅下来，但是鸟窝很高他
栈相关题目
ych9527的博客
05-06 233
文章目录1.每日温度1.1解法11.2解法2 1.每日温度 请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。 例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。 题目链接 1.1解法1 双重for循环，从后往前进行遍历 同时当遍历遇到返回数组之中的0时，代表后面没有比该元
【初阶数据结构】栈和队列（附题目）
2401_82610555的博客
05-30 2361
本文全面介绍栈和队列。栈是特殊线性表，只允许在固定一端操作，遵守后进先出原则。实现时一般用数组更优，介绍了栈的结构体及初始化、入栈出栈等操作函数。队列是特殊线性表，允许一端插入一端删除，先进先出。用链表实现更优，介绍了队列结构体及初始化、入队出队等操作。还给出了栈和队列的面试题解法，如括号匹配用栈实现，用队列实现栈和用栈实现队列，设计循环队列对比了数组和链表实现方式。文末附上了栈和队列的源码，包括头文件和源文件，方便理解和使用。
c语言栈和队列经典题目
01-10
### C语言中的栈和队列经典练习题 #### 括号匹配问题 对于给定的一串字符序列，判断其中的括号是否能够完全匹配。此问题可以通过使用栈的数据结构来解决，在遍历字符串的过程中遇到左括号则将其压入栈中；当遇到右括号时，则尝试与栈顶元素进行配对并弹出栈顶元素[^1]。 ```c bool isValid(char * s){ Stack st; StackInit(&st); while (*s) { if (*s == '[' || *s == '(' || *s == '{') { StackPush(&st, *s); } else { if (StackEmpty(&st)) return false; char top = StackTop(&st); if ((top != '[' && *s == ']') || (top != '(' && *s == ')') || (top != '{' && *s == '}')) { return false; } StackPop(&st); } ++s; } bool result = StackEmpty(&st); StackDestroy(&st); return result; } ``` 这段代码展示了如何利用栈来进行括号匹配验证的功能实现[^2]。 #### 使用队列模拟栈操作 为了加深对这两种线性表的理解，可以设计一种方法通过两个队列完成类似于栈的行为模式——即先进后出（LIFO），这同样是一个很好的实践案例[^3]。 #### 循环队列的设计 考虑到内存管理和性能优化的需求，有时会采用固定长度的数组配合特定算法构建所谓的“循环队列”。这种类型的队列允许逻辑上的首尾相连从而提高空间利用率，并且提供了简单有效的判空/判满条件[^4]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值