Leetcode225. 用队列实现栈

Every day a leetcode

题目来源：225. 用队列实现栈

解法1：单队列模拟栈

• push(x)：与入队一致，直接调用push函数逐个入队即可。
• pop()：让除队尾元素的元素逐个出队，再逐个入队，保持队序不变。这时队尾元素就到达了队首，弹栈操作就是它的出队操作。
• top()：栈首元素就是队尾元素。
• empty()：直接调用队列的empty函数，判定队列是否为空。

代码：

/*
 * @lc app=leetcode.cn id=225 lang=cpp
 *
 * [225] 用队列实现栈
 */

// @lc code=start
class MyStack
{
public:
    queue<int> q;
    MyStack()
    {
    }

    void push(int x)
    {
        q.push(x);
    }

    int pop()
    {
        int size = q.size();
        for (int i = 0; i < size - 1; i++)
        {
            int v = q.front();
            q.pop();
            q.push(v);
        }
        int v = q.front();
        q.pop();
        return v;
    }

    int top()
    {
        return q.back();
    }

    bool empty()
    {
        return q.empty();
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */
// @lc code=end

结果：

复杂度分析：

解法2：双队列模拟栈

• push(x)：往非空队列插入，与入队一致，直接调用push函数逐个入队即可。
• pop()：让除队尾元素的元素逐个出队，再逐个插入另一个队列，保持队序不变。这时队尾元素就到达了队首，弹栈操作就是它的出队操作。
• top()：栈首元素就是非空队列的队尾元素。
• empty()：直接调用两个队列的empty函数，取交判定栈是否为空。

代码：

class MyStack
{
public:
    queue<int> q1;
    queue<int> q2;
    MyStack()
    {
    }

    void push(int x)
    {
        if (!q1.empty())
            q1.push(x);
        else
            q2.push(x);
    }

    int pop()
    {
        if (!q1.empty())
        {
            while (q1.size() > 1)
            {
                int temp = q1.front();
                q2.push(temp);
                q1.pop();
            }
            int v = q1.front();
            q1.pop();
            return v;
        }
        else
        {
            while (q2.size() > 1)
            {
                int temp = q2.front();
                q1.push(temp);
                q2.pop();
            }
            int v = q2.front();
            q2.pop();
            return v;
        }
    }

    int top()
    {
        if (!q1.empty())
            return q1.back();
        else
            return q2.back();
    }

    bool empty()
    {
        return q1.empty() && q2.empty();
    }
};

结果：

复杂度分析：