【力扣-225】用队列实现栈

最新推荐文章于 2024-07-09 23:43:07 发布
最新推荐文章于 2024-07-09 23:43:07 发布
阅读量489 收藏 3
点赞数 4
分类专栏： 数据结构 C语言--学习 文章标签： leetcode 5G 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Djx_hmbb/article/details/130544483
版权

🖊作者 : D. Star.
📘专栏 : 数据结构
😆今日小tips : 有些家里可能会有两个同样名字的 WiFi，而其中一个名字的最后有个 5G，那么，这个 5G 和常说的 5G 信号是一回事吗？并不是，无线路由器上的 5G 指的是 WiFi 的工作频段，手机上的 5G 指的是第五代蜂窝网络技术标准。与普通的 2.4G 频段相比，无线路由器上的 5G 频段的频宽更宽，如果宽带够快，那么就可以有更好的网络体验。但是 5G 频段的覆盖范围要比 2.4G 频段小一些，穿墙能力也要弱一些。

请添加图片描述

文章目录

🔎题目链接：

【力扣-225】用队列实现栈

🔎题目：

请你仅使用两个队列实现一个后入先出（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

🔎分块解释：

✔队列函数：

typedef int QDataType;

typedef struct QueueNode
{
    QDataType data;
    struct QueueNode* next;
}QNode;

typedef struct Queue
{
    QNode* head;
    QNode* tail;
    int size;
}Queue;

//初始化
void InitQueue(Queue* pq)
{
    assert(pq);

    pq->head = NULL;
    pq->tail = NULL;
    pq->size = 0;
}

//销毁
void DestroyQueue(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
        QNode* del = cur;
        cur = cur->next;
        free(del);
        del = NULL;
    }
    pq->head = pq->tail = NULL;
    pq->size = 0;
}

//判断是否为空
bool EmptyQueue(Queue* pq)
{
    assert(pq);

    return pq->head == NULL && pq->tail == NULL;
}

//入队
void PushQueue(Queue* pq, QDataType x)
{
    assert(pq);
    QNode* newNode = (QNode*)malloc(sizeof(QNode));
    if (newNode == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    else
    {
        newNode->data = x;
        newNode->next = NULL;
    }

    if (pq->tail == NULL)
    {
        pq->head = pq->tail = newNode;
    }
    else
    {
        pq->tail->next = newNode;
        pq->tail = newNode;
    }
    pq->size++;
}

//出队
void PopQueue(Queue* pq)
{
    assert(pq);
    assert(!EmptyQueue(pq));

    if (pq->head != pq->tail)
    {
        QNode* del = pq->head;
        pq->head = pq->head->next;
        free(del);
    }
    else
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }

    pq->size--;
}

//取头
QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(!EmptyQueue(pq));

    return pq->head->data;
}

//取尾
QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(!EmptyQueue(pq));

    return pq->tail->data;
}

//队列的长度
int SizeQueue(Queue* pq)
{
    assert(pq);
    return pq->size;
}

✔用队列实现栈：

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;
MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    if (obj == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    InitQueue(&obj->q1);
    InitQueue(&obj->q2);

    return obj;
}

//将元素 x 压入栈顶
void myStackPush(MyStack* obj, int x) {
    assert(obj);
    //法一:
    Queue* empty = &obj->q1;
    Queue* noempty = &obj->q2;
    if (!EmptyQueue(&obj->q1)) {
        empty = &obj->q2;
        noempty = &obj->q1;
    }

    PushQueue(noempty, x);

    //法二:
        // if(!EmptyQueue(&obj->q1))
        // {
        //    PushQueue(&obj->q1,x);
        // }
        // else
        // {
        //    PushQueue(&obj->q2,x);
        // }
}

//移除并返回栈顶元素。
int myStackPop(MyStack* obj) {
    assert(obj);

    Queue* empty = &obj->q1;
    Queue* noempty = &obj->q2;
    if (!EmptyQueue(&obj->q1)) {
        empty = &obj->q2;
        noempty = &obj->q1;
    }

    //将不为空的n-1个移到为空中
    while (noempty->size > 1) {
        PushQueue(empty, QueueFront(noempty));
        PopQueue(noempty);
    }
    int ret = QueueFront(noempty);
    PopQueue(noempty);

    return ret;
}

//返回栈顶元素。
int myStackTop(MyStack* obj) {
    assert(obj);
    //法一:
        // //判断哪一个队列为空
        // Queue* empty = &obj->q1;
        // Queue* noempty = &obj->q2;
        // if(!EmptyQueue(&obj->q1))
        // {
        //     empty = &obj->q2;
        //     noempty = &obj->q1;
        // }

        // //将不为空的n-1个移到为空中
        // while(noempty->size >1){
        //     PushQueue(empty,QueueFront(noempty));
        //     PopQueue(noempty);
        // }
        // int ret = QueueFront(noempty);
        // PushQueue(empty,ret);
        // PopQueue(noempty);

        // return ret;
        
    //法二:
    if (!EmptyQueue(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

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

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

🔎代码详情：

typedef int QDataType;

typedef struct QueueNode
{
    QDataType data;
    struct QueueNode* next;
}QNode;

typedef struct Queue
{
    QNode* head;
    QNode* tail;
    int size;
}Queue;

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

//初始化
void InitQueue(Queue* pq)
{
    assert(pq);

    pq->head = NULL;
    pq->tail = NULL;
    pq->size = 0;
}

//销毁
void DestroyQueue(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
        QNode* del = cur;
        cur = cur->next;
        free(del);
        del = NULL;
    }
    pq->head = pq->tail = NULL;
    pq->size = 0;
}

//判断是否为空
bool EmptyQueue(Queue* pq)
{
    assert(pq);

    return pq->head == NULL && pq->tail == NULL;
}

//入队
void PushQueue(Queue* pq, QDataType x)
{
    assert(pq);
    QNode* newNode = (QNode*)malloc(sizeof(QNode));
    if (newNode == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    else
    {
        newNode->data = x;
        newNode->next = NULL;
    }

    if (pq->tail == NULL)
    {
        pq->head = pq->tail = newNode;
    }
    else
    {
        pq->tail->next = newNode;
        pq->tail = newNode;
    }
    pq->size++;
}

//出队
void PopQueue(Queue* pq)
{
    assert(pq);
    assert(!EmptyQueue(pq));

    if (pq->head != pq->tail)
    {
        QNode* del = pq->head;
        pq->head = pq->head->next;
        free(del);
    }
    else
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }

    pq->size--;
}

//取头
QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(!EmptyQueue(pq));

    return pq->head->data;
}

//取尾
QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(!EmptyQueue(pq));

    return pq->tail->data;
}

//队列的长度
int SizeQueue(Queue* pq)
{
    assert(pq);
    return pq->size;
}

MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    if (obj == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    InitQueue(&obj->q1);
    InitQueue(&obj->q2);

    return obj;
}

//将元素 x 压入栈顶
void myStackPush(MyStack* obj, int x) {
    assert(obj);
    //法一:
    Queue* empty = &obj->q1;
    Queue* noempty = &obj->q2;
    if (!EmptyQueue(&obj->q1)) {
        empty = &obj->q2;
        noempty = &obj->q1;
    }

    PushQueue(noempty, x);

    //法二:
        // if(!EmptyQueue(&obj->q1))
        // {
        //    PushQueue(&obj->q1,x);
        // }
        // else
        // {
        //    PushQueue(&obj->q2,x);
        // }
}

//移除并返回栈顶元素。
int myStackPop(MyStack* obj) {
    assert(obj);

    Queue* empty = &obj->q1;
    Queue* noempty = &obj->q2;
    if (!EmptyQueue(&obj->q1)) {
        empty = &obj->q2;
        noempty = &obj->q1;
    }

    //将不为空的n-1个移到为空中
    while (noempty->size > 1) {
        PushQueue(empty, QueueFront(noempty));
        PopQueue(noempty);
    }
    int ret = QueueFront(noempty);
    PopQueue(noempty);

    return ret;
}

//返回栈顶元素。
int myStackTop(MyStack* obj) {
    assert(obj);
    //法一:
        // //判断哪一个队列为空
        // Queue* empty = &obj->q1;
        // Queue* noempty = &obj->q2;
        // if(!EmptyQueue(&obj->q1))
        // {
        //     empty = &obj->q2;
        //     noempty = &obj->q1;
        // }

        // //将不为空的n-1个移到为空中
        // while(noempty->size >1){
        //     PushQueue(empty,QueueFront(noempty));
        //     PopQueue(noempty);
        // }
        // int ret = QueueFront(noempty);
        // PushQueue(empty,ret);
        // PopQueue(noempty);

        // return ret;
        
    //法二:
    if (!EmptyQueue(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

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

void myStackFree(MyStack* obj) {
    assert(obj);
    DestroyQueue(&obj->q1);
    DestroyQueue(&obj->q2);
    free(obj);
}
感谢家人的阅读,若有不准确的地方 欢迎在评论区指正!

家人们,点个请添加图片描述再走呗~

D. Star.
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
leetcode答案-LeetCode-python:力扣-python
06-30
1. 数据结构：例如，如何使用列表、元组、字典、集合和自定义类来实现栈、队列、堆、链表和树等。 2. 算法：包括查找、排序、动态规划、贪心、回溯、分治等经典算法的Python实现。 3. 字符串操作：Python的内置...
力扣算法-互联网公司常见算法面试题
03-02
1. **数据结构**：在LeetCode中，常见的数据结构包括数组、链表、栈、队列、树、图、哈希表等。Java提供了丰富的内置数据结构类，如ArrayList、LinkedList、Stack、Queue、HashSet、HashMap等，这些都是解题的基础。...
力扣225-用队列实现栈-C++
TLJava^v^的博客
03-08 745
一、运行结果 二、题目 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。 实现 MyStack 类： void push(int x) 将元素 x 压入栈顶。 int pop() 移除并返回栈顶元素。 int top() 返回栈顶元素。 boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。 注意： 你只能使用队列的基本操作 —— 也就是push to back、peek/po..
力扣225 - 用队列实现栈【C/C++实现】
做技术人 · 产优质博客 · 找好工作
11-24 934
力扣225 - 用队列实现栈，教你如何使用单/双队列模拟实现栈
力扣_225 用队列实现栈
qq_24472227的博客
01-08 184
力扣225 用队列实现栈
力扣225-用队列实现栈(C语言版)
weixin_50168448的博客
01-06 278
要用队列实现栈，那我们首先应该明白的是实现栈的目的就是实现它的几个操作：压栈、弹栈、取栈顶元素、判空、求元素个数。那我们现在将每个操作细化来看应该如何实现。 1、压栈：将元素尾插到栈中，队列的入队操也是将元素尾插队中。用队列的入队操作是可以实现的压栈的。 2、取栈顶元素：取栈顶元素实际上就是取队尾的元素。可以用队列直接实现。 3、判空：队列空了栈也就是空的。可以用队列直接实现。 4、求元素个数：求队列中的元素个数即是栈的元素个数。可以用队列直接实现。 5、弹栈：将栈顶元素删除就是删除队尾的元素。队列是先进.
力扣-225. 用队列实现栈
2301_77560317的博客
11-03 48
将队列中的 size - 1个元素弹出再加入队列尾部。然后则可以模拟栈弹出。
力扣-225.用队列实现栈
hero_th的博客
09-23 216
使用两个队列：一个主队列，一个辅助队列首先将元素入队q2，然后将q1的元素全部出队，再入队到q2.再将q1和q2互换，则q1中的元素即为栈内元素。
力扣-用队列实现栈
Jocab_jl的博客
04-20 175
题目描述： 仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通队列的全部四种操作（push、top、pop 和 empty）。 其中： push：将元素 x 压入栈顶 pop：移除并返回栈顶元素 top：返回栈顶元素 empty：如果栈是空的，返回 true ；否则，返回 false 参考代码： class MyStack { private Queue<Integer> queue1; private Queue<Integer> queue2;
力扣-225题 用队列实现栈（C++）
qq_40467670的博客
09-18 150
题目链接：https://leetcode-cn.com/problems/implement-stack-using-queues/ 题目如下： class MyStack { public: //思路：一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部 queue<int> que; int count=0; /** Initialize your data structure here. */ MySta
2021.9.24 力扣-用队列实现栈
销夜的博客
09-24 106
题目描述： 请你仅使用两个队列实现一个后入先出（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 f..
力扣-LeetCode全套2000题目解答C++和Java版.rar
06-26
1. **数据结构**：数组、链表、栈、队列、哈希表、树（二叉树、平衡树如AVL和红黑树）、图等。理解和熟练运用这些数据结构是解决复杂问题的基础。 2. **算法**：排序（快速排序、归并排序、堆排序等）、搜索（二分...
leetcode跳跃-LeetCode:力扣刷题70道！
06-30
225 用队列实现栈 | Implement Stack Using Queue 力扣 622 设计循环队列 | Design Circular Queue 力扣 641 设计循环双端队列 | Design Circular Deque 栈 Stack 力扣 20 有效的括号 | Valid Parentheses 力扣 496 ...
leetcoderust-leetcode-rust:力扣Rust
06-30
2. **Rust数据结构**：如向量（Vec）、字符串（String）、切片（Slice）、哈希映射（HashMap）、队列、堆、栈等，以及如何利用这些内置数据结构来优化算法。 3. **迭代器（Iterators）**：Rust的迭代器模式非常强大...
leetcode--从中序与后序遍历序列构造二叉树
最新发布
liulanba的博客
07-09 613
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树。
力扣双指针算法题目：快乐数
m0_73426459的博客
07-07 338
由图可知，这是一个有环链表，说起链表问题，在判断一个链表是否有环的时候，我们常用的思想就是快慢指针思想，通常来讲就是有两个指针slow和fast，slow初始化在第一个位置，fast初始化在第二个位置，slow一次走一格，fast一次走两格，如果slow指针可以和fast指针相遇，那么就说明这个链表是有环的。如何让快指针dfast每次推进两个格子，我们只要将fast目前所代表的数字调用一下bitsum得到它后面的一个数字，再让它后面的一格数字再次调用一下bitsum就可以了，这便是如下的代码。
Leetcode 3209. Number of Subarrays With AND Value of K
codename_cys的博客
07-07 656
Leetcode 3209. Number of Subarrays With AND Value of K
Leetcode - 周赛404
m0_74859835的博客
07-06 486
leetcode - 周赛404，主要知识点：动态规划，树型dp
力扣 两数组的交集用C语言实现
04-24
如果是交集元素的数量，可以采用哈希表的方式，用一个哈希表来记录第一个数组中的元素出现的次数，然后遍历第二个数组，在哈希表中查找是否存在相同的元素，如果存在，则说明找到了一个交集元素，将其计数并从哈希表...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

D. Star.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值