【DS】两个队列实现栈&两个栈实现队列@Leetcode —— 栈和队列

已于 2022-07-29 17:36:18 修改
阅读量6.1k 收藏 2
点赞数 15
分类专栏： 初阶数据结构 数据结构经典题解 文章标签： leetcode 算法 职场和发展
于 2022-02-08 17:57:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54851255/article/details/122814642
版权

经典题解


这两道题目太经典了，就是栈的先进后出与队列的先进先出，来相互实现对方的性质，很有意思。

在这里插入图片描述

正文开始@边通书

1. 两个队列实现栈

1.1 题目

题目链接：用队列实现栈
在这里插入图片描述

1.2 思路

用两个栈实现队列，就是用队列来满足栈入数据&出数据的性质，即实现后进先出。

💙1. 出数据，把前(n-1)个数据依次转移（东北话倒腾）到另一个队列里，最后一个pop掉。实现后进先出。
在这里插入图片描述
💙2. 入数据，哪一个队列非空，就入哪一个队。保持数据顺序。
在这里插入图片描述

1.3 题解

前置文章：队列@栈和队列

有了思路就开动吧！本题复杂在于它的结构。你要把每个函数接口都做了什么谙熟于心，不然就可能犯错。

把队列基本操作的函数接口暂时省略掉的函数接口去掉 ——

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

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

void myStackPush(MyStack* obj, int x) {
    assert(obj);
    //往非空的队列中入
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        //可以处理q1,q2都为空的情况，就随便找一个入就okay
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    assert(obj);
    // 假设法
    Queue* nonemptyQ = &obj->q1;
    Queue* emptyQ = &obj->q2;
    if(QueueEmpty(&obj->q1))
    {
        nonemptyQ = &obj->q2;
        emptyQ = &obj->q1;
    }
    //1.把前(size-1)个元素倒腾到另一个队列中
    while(QueueSize(nonemptyQ)>1)
    {
        QueuePush(emptyQ,QueueFront(nonemptyQ));
        QueuePop(nonemptyQ);
    }
    //2.把最后一个元素pop掉
    QDataType pop = QueueFront(nonemptyQ);
    QueuePop(nonemptyQ);
    return pop;
}

int myStackTop(MyStack* obj) {
    assert(obj);
    //取队尾元素
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

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

void myStackFree(MyStack* obj) {
    assert(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);
*/

注意：
🖤 1. 初始化时，写成Mystack st; return &st;就是经典的野指针问题。st是局部变量，是调用函数接口来创建结构体，这与在main函数中初始化不同。
🖤 2.在入栈操作我们仍使用了经典的假设法。我们假设的emptyQ和nonemptyQ都是q1和q2的地址，因为都是要对这两个队列本身操作。
🖤 3.两道题目都要注意销毁的处理，否则会发生内存泄漏。free是要分层的，注意释放顺序。
在这里插入图片描述

2. 两个栈实现队列

2.1 题目

题目链接：用栈实现队列
在这里插入图片描述

2.2 思路

第一次做这个的时候，我受到了上一道题目的影响，自己弄了一个天马行空的思路，总之就是倒来倒去，确实没有经典思路好。

总之，还是要满足队列出数据&入数据先进先出的性质。

💙1. 一个栈是pushST，另一个是popST。
出数据时，把pushST中的数据弹栈倒腾到popST中，实现了先进先出。此后，若要出数据，直接在popST弹栈即可。若出空了，就再如上倒腾一下。
在这里插入图片描述

💙2.入数据，就只管往pushST中入就行。保持了数据的顺序。
在这里插入图片描述

2.3 题解

前置文章： 栈@栈和队列
做过上一道题目，有了那么多小注意，这个应该很顺手嘞~它们验主义的都是一样的。

typedef struct {
    ST pushST;
    ST popST;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->pushST);
    StackInit(&q->popST);
    return q;
}

void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    StackPush(&obj->pushST,x);
}

int myQueuePop(MyQueue* obj) {
    assert(obj);
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    int top = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return top;
}

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

bool myQueueEmpty(MyQueue* obj) {
    assert(obj);
    return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}

void myQueueFree(MyQueue* obj) {
    assert(obj);
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

附

还是由于需要借助栈和队列的数据结构，逻辑中再写一遍基本的接口很麻烦，把之前写好的函数接口贴过来了。因为会造成文章冗长，前面都只写了主体逻辑，现在把完整的贴过来嗷，有需要自取。

//两个队列实现栈
typedef int QDataType;

//队列
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QueueNode;

//多个变量，那就用结构体封起来
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDestroy(Queue* pq);

//入队
void QueuePush(Queue* pq, QDataType x);
//出队
void QueuePop(Queue* pq);
//取队头数据
QDataType QueueFront(Queue* pq);
//取队尾数据
QDataType QueueBack(Queue* pq);
//求队列中有效元素个数
int QueueSize(Queue* pq);
//判断队列是否为空？
bool QueueEmpty(Queue* pq);

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	newnode->data = x;
	newnode->next = NULL;
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;//迭代
	}
}

void QueuePop(Queue* pq)
{
	assert(pq);
 	assert(!QueueEmpty(pq));
	QueueNode* newhead = pq->head->next;
	free(pq->head);
	pq->head = newhead;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		cur = cur->next;
		size++;
	}
	return size;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

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

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

void myStackPush(MyStack* obj, int x) {
    assert(obj);
    //往非空的队列中入
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        //可以处理q1,q2都为空的情况，就随便找一个入就okay
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    assert(obj);
    // 假设法
    Queue* nonemptyQ = &obj->q1;
    Queue* emptyQ = &obj->q2;
    if(QueueEmpty(&obj->q1))
    {
        nonemptyQ = &obj->q2;
        emptyQ = &obj->q1;
    }
    //1.把前(size-1)个元素倒腾到另一个队列中
    while(QueueSize(nonemptyQ)>1)
    {
        QueuePush(emptyQ,QueueFront(nonemptyQ));
        QueuePop(nonemptyQ);
    }
    //2.把最后一个元素pop掉
    QDataType pop = QueueFront(nonemptyQ);
    QueuePop(nonemptyQ);
    return pop;
}

int myStackTop(MyStack* obj) {
    assert(obj);
    //取队尾元素
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

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

void myStackFree(MyStack* obj) {
    assert(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);
*/

//两个栈实现队列
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;//栈顶位置
	int capacity;
}ST;

void StackInit(ST* ps);
void StackDestroy(ST* ps);

//压栈
void StackPush(ST* ps, STDataType x);
//出栈
void StackPop(ST* ps);
//取栈顶数据
STDataType StackTop(ST* ps);
//栈中数据多少？
int StackSize(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	//初始化时,top给-1,意味着top指向栈顶数据：先+1,再放数据
	//初始化时，top给0，意味着top指向栈顶数据的下一个：先放数据，再++
	ps->capacity = 0;
}

void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;//有必要，不然就是野指针了
	ps->top = 0;
	ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newcapacity = (ps->capacity == 0) ? 4 : 2 * ps->capacity;
		STDataType* ptr = (STDataType*)realloc(ps->a, newcapacity *sizeof(STDataType));
		if (ptr == NULL)
		{
			printf("realloc failed\n");
			exit(-1);
		}
		ps->a = ptr;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));//断言，栈不为空--这样调用函数不会受到你实现方式的影响
	ps->top--;
}

int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1]; //注意是top - 1
}


typedef struct {
    ST pushST;
    ST popST;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->pushST);
    StackInit(&q->popST);
    return q;
}

void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    StackPush(&obj->pushST,x);
}

int myQueuePop(MyQueue* obj) {
    assert(obj);
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    int top = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return top;
}

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

bool myQueueEmpty(MyQueue* obj) {
    assert(obj);
    return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}

void myQueueFree(MyQueue* obj) {
    assert(obj);
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/
浮光 掠影
关注
  • 15
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 13
    评论
专栏目录
leetcode分类-DS-Algorithm:我的数据结构和算法总结
06-30
leetcode 分类 数据结构类型： 队列 图(，最短路径) Map String 算法类型： 动态规划(，) / 分治 / 贪心 / BFS / DFS 排序()，查找 ，， 背包问题： 其他总结 一些好的资料 别人刷题的一些经验
两个栈实现队列以及两个队列实现栈
jikuidongke5461的博客
09-29 158
两个队列实现栈 思路：队列queue是专职进出栈的，队列help只是个中转站，起辅助作用。 入栈：直接入队列queue即可 出栈：把queue的除最后一个元素外全部转移到队help中,然后把刚才剩下queue中的那个元素出队列。之后把q2中的全部元素转移回q1中(或者两个队列互换) 入栈： 出栈： import java.util.LinkedList; import java.util.Queue; public class QueuesStack { private Queue<In
两个栈实现队列，两个队列实现栈
Canliture
07-14 135
两个栈实现队列 Stack<Integer> stack1 = new Stack<>(); Stack<Integer> stack2 = new Stack<>(); 两个栈实现队列思路： stack1作为数据push源，数据从这里push进去，对应的队列行为就是，从尾push一个数据。 public void push(int node)...
两个栈实现队列/两个队列实现栈
JoliceYu的技术博客
01-07 311
一、题目描述 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。 二、代码 1 自己代码 基本思路：一个栈用于压缩，一个专门用于弹出。因为栈是先进后出，所有的元素入栈再出栈，再入栈就可以将顺序调整过来。但是没有想到优化。 class Solution { public: void push(int node) {
【使用两个队列实现栈】
邓富民的博客
02-28 2232
使用两个队列实现栈的操作
leetcode摇摆-my-Java-DS:我的Java-DS
06-30
线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的(注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表(存储层次上...
leetcode3sumnlogn-leetcode:leetcode
07-01
leetcode 3sum nlogn 编码问题 审查旧代码与早晨咖啡/茶搭配得很好；) Leetcode - DS & Alg : 链表，最小堆 : 二分查找 : 数组，动态规划 : 数组，Kadane 算法 : 树遍历 : 二叉树 : 二叉树 : 二叉树、队列、bfs : ...
leetcode卡-slgAlgo:Python中的经典算法和数据结构
07-06
leetcode卡Python 中的数据结构和算法 用于教育目的 数据结构： 节点 链表 堆 队列 哈希表 二叉搜索树 图形 堆 尝试 算法： 二分查找 插入排序 快速排序 归并排序 一些参考： 线性DS： 数组 101： 数组和字符串： ...
leetcode338-leetcode:leetcode
07-01
章leetcode ds 链表：24、141、206 堆栈 && 队列：20、225、232 优先队列：703 堆：239 哈希表/集：1、15、242、 树&&二叉树&&二叉搜索树：98、235、236 阿尔 递归 分而治之：50，169 贪婪：122 bfs & dfs: 102, 22 ...
[数据结构] 用两个队列实现栈详解
weixin_67596609的博客
03-25 2448
​我们上篇文章讲述了用两个栈实现队列，用过对上篇文章的学习后，我们再去学用两个队列实现栈就变得相对来说容易了很多。本篇文章会对用两个队列实现栈进行详解，希望会对你有所帮助。
两个队列模拟实现栈
m0_63020222的博客
03-25 5329
用两个队列模拟实现栈
LeetCode-两个栈实现队列
Q_LJJ的博客
10-27 2615
两个栈实现队列 两个栈实现队列 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。 (若队列中没有元素，deleteHead 操作返回 -1 ) 思路 队列：先进先出 栈：先进后出 两个栈，一个用来存放数据，一个用来辅助 队列尾部插入：先将data栈中数据移到helper栈中，再将插入的数值入data栈，最后将helper数据搬回data，从而实现先进后出的原则 队列头部删除：因data栈已是队
leetcode-用两个栈实现队列
JR_Chan的博客
04-17 193
 题目来自LeetCode，链接：面试题09. 用两个栈实现队列。具体描述：用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )  示例1： 输入： ["CQueue","appendTail","deleteHead","del...
用两个栈实现一个队列&用两个队列实现一个栈
热门推荐
cherrydreamsover的博客
05-27 7万+
做题之前，我们先来回顾一下“栈和队列的相同点以及不同点”，便于做题时的应用！1.区别与联系相同点：（1）栈和队列都是控制访问点的线性表；              （2）栈和队列都是允许在端点处进行数据的插入和删除的数据结构；不同点：（1）栈遵循“后进先出（LIFO）”的原则，即只能在该线性表的一头进行数据的插入和删除，该位置称为“栈顶”，                        而另外一头...
两个栈实现一个队列/两个队列实现一个栈
Andy-13的博客
04-13 4034
1两个栈实现一个队列 1.原理分析： 队列的主要操作有两个：入队操作和出队操作，出队时从队头出，入队是从队尾插入，入队的操作和入栈的操作类似，而最关键的问题是出队操作，要出队列的是队列的第一个元素，而出栈的是栈的栈顶元素，所以我们可以这样：        假设两个栈A和栈B，A主要用来处理入队操作，B用于处理出队操作。入队操作和入栈操作类似，直接将元素压入栈即可。出队的时候，实现我们假设栈B
剑指Offer面试题7（Java版）：用两个栈实现队列与用两个队列实现栈
D.K专栏
07-27 8549
题目：用两个栈实现一个队列。队列的声明如下，请实现它的两个函数appendTail和deletedHead,分别完成在队列尾部插入节点和在队列头部删除节点的功能。 我们通过一个具体的例子来分析该队列插入和删除元素的过程。首先插入一个元素a，不妨先把它插入到stack1，此时stack1 中的元素有｛a}，stack2为空。再压入两个元素b和c,还是插入到stack1中，此时stack1中的元素有
面试题（两个栈实现一个队列和两个队列实现一个栈）
zhuohaiyy的博客
09-26 2691
面试题（判断元素出栈入栈顺序的合法性。） 面试题（实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)）1，两个栈实现一个队列我们知道栈是后进先出的，而队列是先进先出的 我们创建两个栈input（输入栈），output（输出栈） 我们用input（输入栈）来负责入队，而output（输出栈）来负责出队（反向） 出队是，如果output不为空，
数据结构基础系列(3)：栈和队列
09-08
数据结构课程是计算机类专业的专业基础课程，在IT人才培养中，起着重要的作用。课程按照大学计算机类专业课程大纲的要求，安排教学内容，满足需要系统学习数据结构的人。系列课程包含11个部分，本课为第3部分栈和队列，介绍在系统软件和应用软件开发中大有用途的两种特殊线性表——栈和队列的构组成、存储结构的选择，以及基本运算的实现，通过相关的应用案例介绍了这些数据结构的应用方法。
leetcode两数之和c语言哈希表实现
最新发布
06-02
对于每一个数，计算其与目标值之间的差值，然后在哈希表中查找是否存在该差值，如果存在则返回两个数的下标。时间复杂度为 $O(n)$，空间复杂度为 $O(n)$。虽然空间复杂度较高，但是时间复杂度更低，是较优的解法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浮光 掠影

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值