【栈和队列的相互转换】

最新推荐文章于 2024-02-03 12:15:25 发布
最新推荐文章于 2024-02-03 12:15:25 发布
阅读量1.1k 收藏 5
点赞数 13
分类专栏： 经典例题 文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66363962/article/details/127915035
版权

目录：

前言

打怪升级：第6天
在这里插入图片描述

一、 用队列实现栈

  1. 用队列实现栈

题目描述：
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
实现 MyStack 类：
void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。
注意：
你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。在这里插入图片描述

（一） 题目分析

此关卡要求我们使用两个队列来实现栈的操作，第一步就是需要有队列的基本操作函数，由于C语言没有c++中的stl库可以使用，我们就需要先写出队列的基本操作。

1.队列基本操作

代码如下：

typedef int QDataType;
// 链式结构：队列节点
typedef struct QListNode
{
	QDataType _data;
	struct QListNode* _next;
}QNode;

// 队列的结构 
typedef struct Queue
{
	int len;  // 记录节点的个数
	QNode* _front;
	QNode* _rear;
}Queue;

// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	q->len = 0;
	q->_front = q->_rear = NULL;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
	if (tmp == NULL)
		exit(-1);

	tmp->_data = data;
	tmp->_next = NULL;
	q->len++;
	if (q->_front == NULL) // 空队列
	{
		q->_front = q->_rear = tmp;
	}
	else
	{
		q->_rear->_next = tmp;
		q->_rear = q->_rear->_next;
	}
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);

	if (QueueEmpty(q))
		exit(-1);

	QNode* next = q->_front->_next;
	free(q->_front);
	q->_front = next;
	if(q->_front == NULL)  // 队列只剩下一个数据，删除之后rear成为野指针
	q->_rear = q->_front;
	q->len--;
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);

	if (QueueEmpty(q))
		exit(-1);

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

	if (QueueEmpty(q))
		exit(-1);

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

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

	return q->len == 0;
}
// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);

	QNode* cur = q->_front;
	while (cur)
	{
		QNode* next = cur->_next;
		free(cur);
		cur = next;
	}
}

2.画图分析

栈的特点是“后进先出”而队列的特点是“先进先出”，我们想要使用队列模拟栈就需要通过实验找出它们之间的转换关系，
如下图：
在这里插入图片描述
出栈操作视频解析：

用队列模拟出栈--1


用队列模拟出栈--2

另一个入栈操作：（不推荐）
在这里插入图片描述

3.翻译图解

题目已经明说：在执行pop和top操作时队列不为空，那么我们判不判断这个特殊情况都无所谓了，不过我还是建议大家判断一下，培养良好的做题习惯。
示例：

typedef struct {
	Queue q1;
	Queue q2;
} MyStack; // 栈中元素为两个队列

MyStack* myStackCreate() {
	MyStack* s = (MyStack*)malloc(sizeof(MyStack));
	QueueInit(&s->q1);
	QueueInit(&s->q2);

	return s;
}

void myStackPush(MyStack* obj, int x) {  // 数据需要进到非空队列
	Queue* nonemp = &obj->q1;  //  我们不知道哪一个为非空队列，那就先假设是第一个
	if (!QueueEmpty(&obj->q2))
		nonemp = &obj->q2;

	QueuePush(nonemp, x);
}

int myStackPop(MyStack* obj) {
	Queue* nonemp = &obj->q1;
	Queue* emp = &obj->q2;

	if (!QueueEmpty(&obj->q2))
	{
		nonemp = &obj->q2;
		emp = &obj->q1;
	}

	while (QueueSize(nonemp) > 1) // 非空队列中只剩一个数据时，它就是我们要删除的栈顶数据
	{
		QueuePush(emp, QueueFront(nonemp));
		QueuePop(nonemp);
	}

	QDataType tmp = QueueFront(nonemp); // 记录队尾数据
	QueuePop(nonemp);

	return tmp;
}

int myStackTop(MyStack* obj) {
	Queue* nonemp = &obj->q1;
	if (!QueueEmpty(&obj->q2))
		nonemp = &obj->q2;

	return QueueBack(nonemp);
}

bool myStackEmpty(MyStack* obj) {

	return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);  //两个队列都为空才说明栈为空
}

void myStackFree(MyStack* obj) {
	QueueDestroy(&obj->q1);
	QueueDestroy(&obj->q2);
	free(obj);
}

（二）整体代码

示例：

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

typedef int QDataType;
// 链式结构：表示队列 
typedef struct QListNode
{
	QDataType _data;
	struct QListNode* _next;
}QNode;

// 队列的结构 
typedef struct Queue
{
	int len;
	QNode* _front;
	QNode* _rear;
}Queue;

// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	q->len = 0;
	q->_front = q->_rear = NULL;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
	if (tmp == NULL)
		exit(-1);

	tmp->_data = data;
	tmp->_next = NULL;
	q->len++;
	if (q->_front == NULL) // 空队列
	{
		q->_front = q->_rear = tmp;
	}
	else
	{
		q->_rear->_next = tmp;
		q->_rear = q->_rear->_next;
	}
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);

	if (QueueEmpty(q))
		exit(-1);

	QNode* next = q->_front->_next;
	free(q->_front);
	q->_front = next;
	q->len--;
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);

	if (QueueEmpty(q))
		exit(-1);

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

	if (QueueEmpty(q))
		exit(-1);

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

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

	return q->len == 0;
}
// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);

	QNode* cur = q->_front;
	while (cur)
	{
		QNode* next = cur->_next;
		free(cur);
		cur = next;
	}
}





typedef struct {
	Queue q1;
	Queue q2;
} MyStack;

MyStack* myStackCreate() {
	MyStack* s = (MyStack*)malloc(sizeof(MyStack));
	QueueInit(&s->q1);
	QueueInit(&s->q2);

	return s;
}

void myStackPush(MyStack* obj, int x) {  // 数据需要进到非空队列
	Queue* nonemp = &obj->q1;
	if (!QueueEmpty(&obj->q2))
		nonemp = &obj->q2;

	QueuePush(nonemp, x);
}

int myStackPop(MyStack* obj) {
	Queue* nonemp = &obj->q1;
	Queue* emp = &obj->q2;

	if (!QueueEmpty(&obj->q2))
	{
		nonemp = &obj->q2;
		emp = &obj->q1;
	}

	while (QueueSize(nonemp) > 1)
	{
		QueuePush(emp, QueueFront(nonemp));
		QueuePop(nonemp);
	}

	QDataType tmp = QueueFront(nonemp); // 记录队尾数据
	QueuePop(nonemp);

	return tmp;
}

int myStackTop(MyStack* obj) {
	Queue* nonemp = &obj->q1;
	if (!QueueEmpty(&obj->q2))
		nonemp = &obj->q2;

	return QueueBack(nonemp);
}

bool myStackEmpty(MyStack* obj) {

	return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
	QueueDestroy(&obj->q1);
	QueueDestroy(&obj->q2);
	free(obj);
}

提交结果：在这里插入图片描述

补充：题目下方的进阶要求->使用一个队列模拟实现栈
提示：循环队列

二、用栈实现队列

  1. 用栈实现队列

题目描述：
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
说明：
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
在这里插入图片描述

（一） 题目分析

此关卡通关要求为：使用两个栈来模拟实现队列完成基本操作。
那么第一步同上：写出栈的基本操作

1.栈基本操作

代码如下：

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);

	ps->_a = (STDataType*)malloc(sizeof(STDataType) * 3);
	ps->_top = 0;
	ps->_capacity = 3;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);

	if (ps->_top == ps->_capacity)
	{
		STDataType* tmp = realloc(ps->_a, sizeof(STDataType) * ps->_capacity * 2);
		assert(tmp);

		ps->_a = tmp;
		ps->_capacity *= 2;
	}

	ps->_a[ps->_top++] = data;
}
// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);

	if (StackEmpty(ps))
		exit(-1);

	ps->_top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);

	if (StackEmpty(ps))
		exit(-1);

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

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

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

	free(ps->_a);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}

2.画图分析

栈的特点是后进先出，队列的特点为先进先出，下面我们通过画图来找到它们之间的转换关系
在这里插入图片描述
视频解析：

用栈模拟出队--1


用栈模拟出队--2

3.翻译图解

代码如下：

typedef struct {
	Stack instack;
	Stack outstack;
} MyQueue; // 两个栈模拟队列，从画图我们可以看出一个栈是专门用来入数据的，另一个是用来出数据的


MyQueue* myQueueCreate() {

	MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
	StackInit(&q->instack);
	StackInit(&q->outstack);

	return q;
}

void myQueuePush(MyQueue* obj, int x) {

	StackPush(&obj->instack, x);
}

int myQueuePeek(MyQueue* obj) {
	if (StackEmpty(&obj->outstack))
	{
		while (!StackEmpty(&obj->instack))
		{
			StackPush(&obj->outstack, StackTop(&obj->instack));
			StackPop(&obj->instack);
		}
	}

	return StackTop(&obj->outstack);
}

int myQueuePop(MyQueue* obj) {

	STDataType con = myQueuePeek(obj);

	StackPop(&obj->outstack);

	return con;
}

bool myQueueEmpty(MyQueue* obj) {

	return StackEmpty(&obj->instack) && StackEmpty(&obj->outstack);
}

void myQueueFree(MyQueue* obj) {

	StackDestroy(&obj->instack);
	StackDestroy(&obj->outstack);
	free(obj);
}

（二）整体代码

示例：


// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);

	ps->_a = (STDataType*)malloc(sizeof(STDataType) * 3);
	ps->_top = 0;
	ps->_capacity = 3;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);

	if (ps->_top == ps->_capacity)
	{
		STDataType* tmp = realloc(ps->_a, sizeof(STDataType) * ps->_capacity * 2);
		assert(tmp);

		ps->_a = tmp;
		ps->_capacity *= 2;
	}

	ps->_a[ps->_top++] = data;
}
// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);

	if (StackEmpty(ps))
		exit(-1);

	ps->_top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);

	if (StackEmpty(ps))
		exit(-1);

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

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

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

	free(ps->_a);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}


typedef struct {
	Stack instack;
	Stack outstack;
} MyQueue;


MyQueue* myQueueCreate() {

	MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
	StackInit(&q->instack);
	StackInit(&q->outstack);

	return q;
}

void myQueuePush(MyQueue* obj, int x) {

	StackPush(&obj->instack, x);
}

int myQueuePeek(MyQueue* obj) {
	if (StackEmpty(&obj->outstack))
	{
		while (!StackEmpty(&obj->instack))
		{
			StackPush(&obj->outstack, StackTop(&obj->instack));
			StackPop(&obj->instack);
		}
	}
	
	return StackTop(&obj->outstack);
}

int myQueuePop(MyQueue* obj) {

	STDataType con = myQueuePeek(obj);

	StackPop(&obj->outstack);

	return con;
}

bool myQueueEmpty(MyQueue* obj) {

	return StackEmpty(&obj->instack) && StackEmpty(&obj->outstack);
}

void myQueueFree(MyQueue* obj) {

	StackDestroy(&obj->instack);
	StackDestroy(&obj->outstack);
	free(obj);
}

提交结果：
在这里插入图片描述

补充：题目下方的进阶要求->实现每个操作均摊时间复杂度为 O(1) 的队列，
那么细心的朋友应该能发现有可能出现O(n)时间复杂度的地方就是计算队列的元素个数上，而我们这里使用并没有使用这些操作，这里我们其实已经达到了进阶要求。

总结

好了朋友们，以上就是栈和队列相互转换使用的例题了，我想当我们打过了这两关后我们对栈和队列的特点和用法理解都会上一个新的台阶。
如果有什么疑问或者建议都可以在评论区留言，感谢大家对在这里插入图片描述的支持。

胜利熊猫
关注
专栏目录
栈与队列的相互转化.rar
08-12
队列是先进先出，有队头和队尾，因此用第一个栈的栈顶表示队头，第二个表示队尾。 2. 队列插入的时候是从尾巴插入，因此代表尾部的栈可以定义成一个插入栈也是队尾栈。 3. 队列输出遵守先进先出原则，输出的元素是队...
栈和队列的相互转换
weixin_30698527的博客
07-27 324
　　大家都知道，栈是先进后出，队列是先进先出的。那么如何使用栈来完成队列的功能，又如何用队列完成栈的功能呢？ 一、两个栈实现队列 　　两个栈实现队列的方法就是将一个栈用来当作进入元素的入口，当要取出元素的时候，就将这个栈中的元素转入到另外一个栈中，由于先进后出，此时第二个栈中的元素顺序就和第一个栈中的元素顺序相反，这样就实现了一个队列的功能。具体流程如下： 　　1、将元素进栈 　　2、...
栈和队列的转换
lmbuhuiku的博客
05-01 669
栈1就会为空，之后我们想要输入数据就向栈1当中输入，想要拿出数据据从栈2当中拿，当我们栈2当中的数据全部拿完时，我们再将栈1当中的数据全部转入栈2当中即可。我们的栈每次只能从栈顶插入数据从栈顶拿出数据，当我们想要以队列的形式拿出数据的时候，也就是从栈的底端拿出数据，我们就必须一个一个将数据全部搬运到另一个栈当中。我们剩下的最后一个数据也就是我们以队列的形式想要出的数据。我们会发现我们移入栈2当中的数据全部已经是排好顺序的了，那么我们每次出数据的时候只需要从栈2当中拿出数据得到的就是我们队头的数据。
栈和队列的转化
xiaobai230811的博客
12-17 1298
栈与队列的相互转换栈和队列是两种基本的数据结构，它们在许多算法和程序中都有应用。虽然栈和队列在概念上是完全不同的，但是我们可以使用两个栈来实现一个队列，或者使用两个队列来实现一个栈。这种转换在某些情况下可能非常有用，例如，当我们的编程环境只提供了栈或队列的实现，但我们需要使用另一种数据结构时。在这篇博客中，我们将详细介绍如何使用两个栈来实现一个队列，以及如何使用两个队列来实现一个栈。我们将提供详细的代码示例，并解释每个函数的工作原理。提示：以下是本篇文章正文内容，下面案例可供参考。
栈转换为队列
m0_58743727的博客
05-12 441
栈转换为队列
栈与队列之间的互相转换
luren2015的博客
07-02 356
一、基本概念 1、栈stack：先进后出 FILO 2、队列queue：先进先出 FIFO 二、两个栈实现一个队列 1、入队：push到栈1 2、出队： （1）若栈2为空，push到栈2，再从栈2 依次pop （2）若栈2非空，先将栈2 数据依次pop，直到为空，再执行步骤（1） 三、两个队列实现一个栈 1、入栈：push数据 “abc” 到一个不为空的队列，若全为空，即均可 2、 出栈： （1） 将队1数据（除了最后一个）“ab” push到队2（空）中，将队1中..
栈和队列的应用实现 进制间的相互转换 C++
11-03
栈和队列的应用实现 进制间的相互转换 C++
JS实现利用两个队列表示一个栈的方法
11-27
虽然这不是最直接或效率最高的实现方式，但它展示了数据结构间转换的概念，并且可以作为理解数据结构相互关系的一个练习。在实际应用中，使用原生的Array对象提供的push和shift方法通常能更高效地实现栈操作。不过，...
队列实现栈_栈_数据结构_队列_
09-30
在计算机科学中，数据结构是组织和...了解和掌握这些基本数据结构及其相互转换的方法，对于提升编程能力和解决问题的能力大有裨益。在实际编程中，灵活运用不同的数据结构，能帮助我们更好地设计高效、优雅的解决方案。
通过2个栈 模拟队列。
04-24
队列和栈是两种基本的数据结构，它们各自有着特定的操作模式。队列遵循“先进先出”（FIFO, First In First Out）原则，而栈则遵循“后进先出”（LIFO, Last In First Out）原则。然而，有时我们可能需要使用一种...
栈与队列的相互转换
洋葱汪的博客
05-17 1082
1、问题  栈和队列在实现上非常类似， 是否可以用栈实现队列？ 问题分析                       用栈实现队列等价于用“后进先出”的特性实现 "先进先出" 的特性！  解决方案设计    实现思路                准备两个栈用于实现队列： stack_in 和 stack_out                      ▪ 当有新元素入队时：将其...
使用栈实现队列
li15006474642的博客
09-06 123
栈的特性是先进后出，队列的特性是先进先出，这就照成这两种数据结构不同的性质 1、将一个栈中的元素转移到另一个栈中，数据的顺序会发生变化 2、将一个队列的数据转移到另一个队列中，数据的顺序不会发生变化 因此使用栈实现队列，使用两个栈，一个栈用来接收数据，并将接收的数据转移到另一个栈用来抛出数据。这样就完成了先进先出的特点 ...
将一个栈的数据转移到另一个栈（递归实现）
cool-wangtongzhou
04-16 1741
void TranStack(SqStack*& s1, SqStack*& s2) { ElemType e; if (!StackEmpty(s1)) { Pop(s1, e); TranStack(s1, s2); Push(s2,e); } } 这里if的括号中也可以写成s->top!=-1,一个意思的，只不过上面是引用了一个函数
栈迁移原理介绍与应用
weixin_39529207的博客
02-20 5494
本文将对CTF Pwn中「栈迁移」（又称「栈转移」）这一技术进行介绍与分析，希望读完本文后以下问题将不再困扰你： 什么是栈迁移？ 栈迁移解决了什么问题？ 怎么使用栈迁移这个技巧？ 开始之前，有如下预备知识会极大提升你的阅读体验： CTF Pwn是在做什么？提权（Getshell）是什么意思？ 在操作系统内存布局中，栈是一种怎样的结构，具有怎样的特点？ x86中常用寄存器的名称与作用？函数调用栈的原理与过程是怎样的？ 栈溢出攻击的核心技巧是什么？ 栈溢出是怎么回事？  在预备知识的4个问
栈迁移：三种利用方法
最新发布
2302_79813730的博客
02-03 1556
栈迁移一般用于溢出字节不够，但至少溢出0x10个字节，也就是用来覆盖rbp及返回地址，一般有两种方向：迁向原来的的栈，迁移到bss段。在学习栈迁移之前，需要了解一下一个汇编指令：leave ret，他的作用可以拆分成两部分：mov rsp rbp pop rbp。leave ret的作用是用来清空栈的，在主函数最后都会有，但如果用两次会有怎样的效果呢借用了这篇。
【数据结构与算法】用队列实现栈&&用栈实现队列&&设计循环队列
joy.728的博客
10-18 1440
三道经典的OJ题：用队列实现栈、用栈实现队列和设计循环队列，点进来保证你能学会！！！
栈和队列的相互转化，请在画图模拟。
06-10
栈和队列是两种常用的线性数据结构，它们可以相互转化。 首先，我们来看如何将队列转化为栈。我们可以使用两个队列来实现。假设现在有一个队列 Q1 和一个空队列 Q2，我们...以上是栈和队列相互转化的方法及示意图。
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值