用队列实现栈

最新推荐文章于 2024-05-19 20:00:00 发布
最新推荐文章于 2024-05-19 20:00:00 发布
阅读量571 收藏 19
点赞数 23
文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67371175/article/details/138041948
版权

请你仅使用两个队列实现一个后入先出（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（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

  • 1 <= x <= 9
  • 最多调用100 次 push、pop、top 和 empty
  • 每次调用 pop 和 top 都保证栈不为空

进阶：你能否仅用一个队列来实现栈。

队列代码

这里我采用的是c语言，没有库手撕了队列代码如下

typedef int QueueData;
struct QueueNode
{
	QueueData val;
	struct QueueNode* next;
};
typedef struct QueueNode QNode;
typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Que;
void QueueInit(Que* pq);//队列初始化
void QueueDestroy(Que* pq);//队列销毁

void QueuePush(Que* pq,QueueData x);//入队列
void QueuePop(Que* pq);//出队列

QueueData QueueBack(Que* pq);
QueueData QueueFront(Que* pq);
bool QueueEmpty(Que* pq);
int QueueSize(Que* pq);

void QueueInit(Que* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}
void QueueDestroy(Que* pq)
{
	QNode* pcur = pq->phead;
	while (pcur)
	{
		QNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;	
}

void QueuePush(Que* pq,QueueData x)
{
	assert(pq);
	QNode* newnode = (Que*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	newnode->val = x;
	newnode->next = NULL;
	if (pq->ptail)
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	else
	{
		pq->phead = pq->ptail = newnode;
	}
	pq->size++;
}
void QueuePop(Que* pq)
{
	assert(pq->phead != NULL);

	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead =pq->ptail= NULL;
	}
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead); 
		pq->phead = next;
	}
	pq->size--;
}

QueueData QueueFront(Que* pq)
{
	assert(pq!=NULL);

	assert(pq->phead != NULL);
	return pq->phead->val;
}
QueueData QueueBack(Que* pq)
{
	assert(pq!=NULL);

	assert(pq->ptail != NULL);
	return pq->ptail->val;
}
bool QueueEmpty(Que* pq)
{
	return pq->phead == NULL;
}
int QueueSize(Que* pq)
{
	assert(pq);
	return pq->size;

}

分析

 题目要求我们实现这些代码，但栈和队列又是相反并且题目要求用俩个队列去实现栈

上图是题目中给的结构体这里的结构体没有名字这里是匿名结构体，用下面那个名字就行，这里我们给结构体的成员加上我们俩个队列 

 如下图Que这里定义的是phead 和ptail俩个节点，这俩个节点的类型又是Qnode类型

 Qnode的底层又是一个链表

 也就是说他们是一种嵌套关系，下图的1，2，3则是链表

 

这样第一个接口就写好了 

1.MyStack

2.MyStack* myStackCreate

这里用的是一个函数初始化并且返回指针，记住不要用局部变量创建然后返回，值可以正常返回但是返回了以后原来在栈区创建的变量已经销毁就变成了野指针所这里用堆区的malloc然后初始化

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

3. void myStackPush

因为队列和栈是相对的一个是先进后出一个是后进先出这里看哪一个队列是空的就插入哪一个

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

 4. int myStackPop

首先要明白队列和栈是相对的，那么出栈的时他们俩个就是这样的

 

如果用用俩个队列去模拟栈那么如下图，如果要把pop  4那么就需要先把1，2，3这n-1

的数据移动到第一个队列中，然后再把4释放掉 

 

 

 这样就出栈了

int myStackPop(MyStack* obj) {
    Que* pEmptyQ=&obj->q1;
    Que* pNonEmptyQ=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        pEmptyQ=&obj->q2;
        pNonEmptyQ=&obj->q1;
    }
    while(QueueSize(pNonEmptyQ)>1)
    {
        int front=QueueFront(pNonEmptyQ);
        QueuePush(pEmptyQ,front);
        QueuePop(pNonEmptyQ);
        
    }
    int front=QueueFront(pNonEmptyQ);

    QueuePop(pNonEmptyQ);
    return front;

}

 

5.int myStackTop

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

5.bool myStackEmpty

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

7.void myStackFree

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

    free(obj);
}

完整代码

typedef int QueueData;
struct QueueNode
{
	QueueData val;
	struct QueueNode* next;
};
typedef struct QueueNode QNode;
typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Que;
void QueueInit(Que* pq);//队列初始化
void QueueDestroy(Que* pq);//队列销毁

void QueuePush(Que* pq,QueueData x);//入队列
void QueuePop(Que* pq);//出队列

QueueData QueueBack(Que* pq);
QueueData QueueFront(Que* pq);
bool QueueEmpty(Que* pq);
int QueueSize(Que* pq);

void QueueInit(Que* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}
void QueueDestroy(Que* pq)
{
	QNode* pcur = pq->phead;
	while (pcur)
	{
		QNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;	
}

void QueuePush(Que* pq,QueueData x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	newnode->val = x;
	newnode->next = NULL;
	if (pq->ptail)
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	else
	{
		pq->phead = pq->ptail = newnode;
	}
	pq->size++;
}
void QueuePop(Que* pq)
{
	assert(pq->phead != NULL);

	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead =pq->ptail= NULL;
	}
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead); 
		pq->phead = next;
	}
	pq->size--;
}

QueueData QueueFront(Que* pq)
{
	assert(pq!=NULL);

	assert(pq->phead != NULL);
	return pq->phead->val;
}
QueueData QueueBack(Que* pq)
{
	assert(pq!=NULL);

	assert(pq->ptail != NULL);
	return pq->ptail->val;
}
bool QueueEmpty(Que* pq)
{
	return pq->phead == NULL;
}
int QueueSize(Que* pq)
{
	assert(pq);
	return pq->size;

}

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


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

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    Que* pEmptyQ=&obj->q1;
    Que* pNonEmptyQ=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        pEmptyQ=&obj->q2;
        pNonEmptyQ=&obj->q1;
    }
    while(QueueSize(pNonEmptyQ)>1)
    {
        int front=QueueFront(pNonEmptyQ);
        QueuePush(pEmptyQ,front);
        QueuePop(pNonEmptyQ);
        
    }
    int front=QueueFront(pNonEmptyQ);

    QueuePop(pNonEmptyQ);
    return front;

}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

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

    free(obj);
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

落笔映浮华丶
关注
  • 23
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用队列实现栈(java代码).docx
03-24
用队列实现栈(java代码).docx
【数据结构与算法】用队列实现栈
Welcome home | Jian Liao 's blog
03-21 1766
😼前面我们相继实现了栈和队列，是不是愁没有练手的地方呢？别担心，本章带大家用队列来实现一个栈！😽我们都知道，栈和队列可以看作为兄弟，一个后进先出(LIFO)，一个先进先出(FIFO)，他们虽有不同的性质，但总的来说还是不分家的，因为，我们既可以用队列实现栈，也可以用栈实现队列，而本章就先来带大家来了解如何使用队列来实现栈。💝学会了用队列实现栈，那么下一篇文章就是教大家如何用栈实现队列了。栈和队列还真是有趣呢！❤️‍🔥后续将会持续输出有关数据结构的文章，你们的支持就是我写作的最大动力！
用队列实现栈(Java语言实现)
qq_43751200的博客
07-05 210
用队列实现栈
C语言用队列实现栈
Ctrl_C_V_is_easy的博客
10-03 381
队列的特点是先进先出，而栈是先进后出，我们能否用队列来实现栈的特征呢，当然是可以的，我们需要两个队列来实现，实现入栈操作时只需要选择一个队列正常入队即可，出栈时则需要把不为空的队列的前N-1个元素全部转移到另一个队列，再将剩下的一个元素出队即可。
《数据结构初阶》用队列实现栈&&用栈实现队列的细致解析
m0_62171658的博客
03-29 3982
《数据结构初阶》用队列实现栈&&用栈实现队列的细致解析
用栈实现队列和用队列实现栈
SmileTimLi的博客
02-23 1763
第一 队列和栈的了解 栈 -- 先进后出(FILO—First-In/Last-Out) 队列 -- 先进先出(FIFO—first in first out) 对应的方法 栈 入栈：s.push(x) 出栈：s.pop() 访问栈顶：s.top() 判断栈空：s.empty() 访问栈中的元素个数：s.size() 队列  入队：q.push(x) 出队：q.pop(...
如何使用JavaScript实现栈与队列
10-16
主要介绍了如何使用JavaScript实现栈与队列。栈和队列是web开发中最常用的两种数据结构。绝大多数用户，甚至包括web开发人员，都不知道这个惊人的事实。,需要的朋友可以参考下
如何使用两个栈实现队列Java
08-25
主要介绍了如何使用两个栈实现队列Java,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
daacheng#PythonBasic#用队列实现栈1
07-25
225.用队列实现栈题目使用队列实现栈的下列操作：* pop() -- 移除栈顶元素* top() -- 获取栈顶元素* empty() -- 返回栈是否为空代
（Python3）数据结构–队列之用队列实现一个栈
12-21
提出这样的一个问题，如何用队列去模拟栈，或者说，用队列实现栈的效果，即先进后出？队列和栈的区别无非是先进先出和先进后出，那么在之前的博客中，二者的数据存储都是用的list类型，入队和入栈都是从list类型的...
【初阶数据结构】带头双向循环链表讲解
s1mplewo的博客
05-15 1228
本文详细讲解了带头双向循环链表的概念及具体实现源码
【数据结构】习题 |树与二叉树 |森林 |哈夫曼树 |线索二叉树
2301_77611317的博客
05-19 685
15道题 涉及树与二叉树、哈夫曼树、线索二叉树、森林等知识点本文主要介绍了15道涉及到树与二叉树、哈夫曼树、线索二叉树、森林等知识点的练习题如果文章的论述或代码等出现错误，欢迎前来指正！
数据结构-栈(带图)
2302_78381559的博客
05-16 771
栈（Stack）是一种基本的数据结构，其特点是只允许在同一端进行插入和删除操作，这一端被称为栈顶。遵循后进先出（Last In, First Out, LIFO）原则，即最后存入栈中的元素最先被取出。形象地讲，栈就像是生活中堆放盘子的架子，我们总是把新的盘子放在最上面，而需要拿盘子时也是从最上面开始拿。
每周一算法：恰好经过K条边的最短路
少儿编程乔老师
05-15 756
给定一张由M条边构成的无向图，求从起点S到终点E恰好经过K条边（可以重复经过）的最短路。可以使用快速幂倍增 + Floyd 求解。
408数据结构-并查集 自学知识点整理
Engels_Si_Fish的博客
05-15 980
25考研知识点个人向总结。
5.16数据结构第五章（树，深林）
2302_81921490的博客
05-16 129
1.树的存储结构 1.1双亲表示法 1.2孩子表示法 1.3孩子兄弟表示法 小结 2.树，深林与二叉树的转换 2.1树->二叉树的转换过程 2.2深林->二叉树的转换过程 2.3二叉树->深林的转换过程 2.4二叉树->树的转换过程 小结 3.树和深林的遍历 3.1树的遍历 3.1.1树的先根遍历 3.1.2树的后根遍历 3.1.3树的层次遍历 3.2深林的遍历 3.2.1深林的先序遍历
数据结构绪论
weixin_62944148的博客
05-17 1031
考研人复试必看
【c语言】TIMI哥听课笔记
EllaZeng的博客
05-16 1363
函数的声明，需要告诉编译器函数的一些信息：返回类型，参数列表，函数名#pragma once//防止头文件重复包含函数定义中，参数名不可省略。
基于matlab实现人工免疫算法的解决TSP问题的方法
最新发布
05-21
基于matlab实现人工免疫算法的解决TSP问题的方法，体现了免疫算法在进化计算过程中的抗原学习、记忆机制、浓度调节机制以及多样性抗体保持策略等优良特性.rar
用c的方法用队列实现栈
04-12
使用队列实现栈的方法一般是通过两个队列来实现。具体来说，我们可以按照以下步骤实现： 1. 创建两个队列queue1和queue2； 2. 将新元素入队到queue2中； 3. 将queue1中的所有元素出队并入队到queue2中，直到queue1...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值