【栈和队列的相互转换】

最新推荐文章于 2024-06-09 16:39:02 发布
最新推荐文章于 2024-06-09 16:39:02 发布
阅读量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)时间复杂度的地方就是计算队列的元素个数上，而我们这里使用并没有使用这些操作，这里我们其实已经达到了进阶要求。

总结

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

胜利熊猫
关注
  • 13
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 14
    评论
专栏目录
【数据结构】栈和队列之间的相互转换
qq_43669007的博客
08-04 513
1.用队列实现栈 队列：先进先出； 栈：先进后出； 实现的方法有：添加元素、删除栈顶元素（删除队列的最后一个）、返回栈顶元素（返回队列的最后一个）、判断栈（队列）是否为空； import java.util.*; public class Main { //利用队列实现栈 Queue<Integer> queue = new LinkedList<>(); //添加元素 public void push(int value){
C++数组实现栈和循环队列，栈和队列的相互转化
CSDN_dzh的博客
01-18 878
队列声明 方法实现 核心部分是当队头或队尾来到最后一个位置时，让它们变为0，这个时候就不用考虑复杂的边界了 测试结果及代码 #include &amp;amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;amp;lt;vector
数据结构实验之栈一：进制转换
wa123579的博客
02-13 467
Problem Description输入一个十进制非负整数，将其转换成对应的 R (2 <= R <= 9) 进制数，并输出。 Input第一行输入需要转换的十进制非负整数； 第二行输入 R。 Output输出转换所得的 R 进制数。 Example Input1279 8 Example Output2377 HintAuthor#include <stdio.h> int mai
栈和队列的转换
最新发布
2301_80706853的博客
06-09 588
栈和队列的转换
栈与队列之间的互相转换
luren2015的博客
07-02 334
一、基本概念 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中..
栈与队列的相互转化.rar
08-12
队列是先进先出，有队头和队尾，因此用第一个栈的栈顶表示队头，第二个表示队尾。 2. 队列插入的时候是从尾巴插入，因此代表尾部的栈可以定义成一个插入栈也是队尾栈。 3. 队列输出遵守先进先出原则，输出的元素是队...
栈和队列的应用实现 进制间的相互转换 C++
11-03
栈和队列的应用实现 进制间的相互转换 C++
栈和队列的相互转化，请在画图模拟。
06-10
栈和队列是两种常用的线性数据结构，它们可以相互转化。 首先，我们来看如何将队列转化为栈。我们可以使用两个队列来实现。假设现在有一个队列 Q1 和一个空队列 Q2，我们...以上是栈和队列相互转化的方法及示意图。
栈转换为队列
m0_58743727的博客
05-12 429
栈转换为队列
基础数据结构——利用两个栈实现一个队列
Sauron7i的博客
09-03 271
利用两个栈实现一个队列规则结构体定义队列的操作初始化入队出队清空和销毁只读接口 规则 入队：一直向stack1中插入数据 出队：1.如果stack2不空，则从stack2中出； 2.如果stack2空，则先把stack1中的数据导入到stack2中，再从stack2出栈。 示例： 栈是先入后出，队列是先入先出。 如图，将数据1，2，3插入栈stack1中，把stack1中的数据出到stack2中，这时候是按3，2，1插入stack2中，再从stack2中出数据，保持先入后出原则。 整体来看，是数据1，2
特殊数据结构：栈和队列的相互转化
07-12 250
队列是一种先进先出的数据结构，栈是一种先进后出的数据结构，形象一点就是这样： 目录 1、LeetCode232. 用栈实现队列 2、LeetCode225. 用队列实现栈 1、LeetCode232. 用栈实现队列 使用栈实现队列的下列操作： push(x) -- 将一个元素放入队列的尾部。 pop() -- 从队列首部移除元素。 peek() -- 返回队列首部的元素。 empty() -- 返回队列是否为空。 示例: MyQueue queue = new MyQueue()..
栈和队列的相互转换
pyy18829518070的博客
10-08 609
栈的特点  ：先进后出；队列的特点：先进先出。所以要实现栈和队列的互换，必须互相模拟彼此的特点。     比如，用两个队列实现栈，一个队列模拟为入栈队列，一个队列模拟为出栈队列，入栈与普通栈相同，而出栈，首先要获得入栈 队列的长度，将入栈队列中的元素除去最后一个元素依次出队，并且同时依次入出栈队列，然后将最后一个入栈队列里的元素出队即 删除，最后把出栈队列中的元素再依次出队入入栈队列，即
栈和队列之间的转换
Wpan的博客
07-28 804
1、栈和队列都是限制性的线性表结构。 （1）、栈的元素存储顺序为：LIFO（先进后出） （2）、队列的元素粗春顺序为：FIFO（先进先出）   2、栈和队列之间相互转换的两个问题 （1）、用两个栈实现一个队列 思路：由于栈的存储顺序为“先进后出”，所以： 1）、可以将栈1作为一个插入栈，栈2作为一个弹出栈。 2）、将元素插入栈1，并判断栈2是否为
栈队列互相转换
qq_37290134的博客
11-06 483
两个 队列 实现 栈：   队列结构是先入先出，用两个队列结构，数组从队列1到队列2，元素顺序不会变。 栈结构是先入后出。即每次出栈的内容都是将队尾弹出，所以准备两个队列， 主队列 一个是加入数据的时候进入的队列（用来入栈） 辅队列 一个是弹出数据的时候（弹出队尾数据）所需队列。 弹出数据：将队列1 中的数据依次加入队列2，直到队列1中只剩一个数据为止。此时剩余的数据便是栈需要弹出的数...
栈与队列的互相转化
weixin_30633949的博客
05-07 141
问题描述：实现栈与队列的互相转化。 分析：曾今碰到过的一个面试题目，面试官要求如何用队列实现栈，有这个问题进而又引出了如何用栈实现队列，和大家分享下。 解法： 用队列实现栈：栈的特点是先进后出，而队列的特点是先进先出，只用一个队列是不可能实现栈的，因此可以使用两个队列来实现 设两个队列分别是Q1和Q2，当需要将元素压栈时，将元素进入队列Q1，如果要出栈，则将Q1...
栈变队列，队列变栈，猫狗队列
qq_43091156的博客
02-28 229
栈：先进后出； 队列：先进先出； 栈变队列：用两个栈结构实现队列结构。 思想：定义一个stackPush栈用来存放添加进来的元素，定义一个stackPop栈用来返回队列的poll方法。一开始将添加的元素放入到Push栈里面，然后如果要调用队列的poll方法时，使用while循环将Push栈里面的元素全部放入到Pop栈里面，再返回Pop栈的pop方法。 代码： public static cla...
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值