【LeetCode题解】225_用队列实现栈（Implement-Stack-using-Queues）

最新推荐文章于 2022-05-18 23:50:08 发布
最新推荐文章于 2022-05-18 23:50:08 发布
阅读量219 收藏
点赞数
分类专栏： LeetCode 文章标签： leetcode stack queue
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x273591655/article/details/84729232
版权

更多 LeetCode 题解笔记可以访问我的 github。

文章目录

描述

使用队列实现栈的下列操作：

  • push(x) – 元素 x 入栈
  • pop() – 移除栈顶元素
  • top() – 获取栈顶元素
  • empty() – 返回栈是否为空

注意:

  • 你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
  • 你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
  • 你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

解法一：双队列，入快出慢

思路

为了实现栈这种数据结构后入先出（last in first out, LIFO）的效果，解法一借助于两个队列。其中，一个队列保存栈的所有元素（设为队列1 q1），另一个队列用于辅助实现入栈、出栈的效果（设为队列2 q2）。相关操作的底层实现细节见下面对应的小节。

入栈（push）

入栈时，直接将新的元素 x 压入队列1 q1 的队尾（rear），并且用变量 top 保存栈顶元素，方便后面的查看栈顶元素（peek）操作，具体的实现步骤见图1。

在这里插入图片描述

图1：将一个元素压入栈

代码（Java）实现如下：

/** Push element x onto stack. */
public void push(int x) {
    top = x;
    q1.add(x);
}

复杂度分析如下：

  • 时间复杂度： O ( 1 ) O(1) O(1)
  • 空间复杂度： O ( 1 ) O(1) O(1)

出栈（pop）

由于入栈时直接将元素入队到队列1 q1 中，因此，栈顶的元素位于队列1 q1 的尾部。为了能将栈顶元素（队列1 q1 尾部的元素）弹出，必须先将队列1 q1 队尾之前的元素出队。这里，我们借助另一个队列（辅助队列 q2）实现这一过程——将队列1 q1 队尾之前的元素出队并入队到队列2 q2 中。 之后，将队列1 q1 中唯一个元素（栈顶元素）出队。最后，再将两个队列的引用进行交换即可完成出栈操作。具体的实现步骤如图2所示。

在这里插入图片描述

图2：将一个元素出栈

代码（Java）实现如下：

/** Removes the element on top of the stack and returns that element. */
public int pop() {
    if (q1.size() == 0) {
        throw new NoSuchElementException("[ERROR] The queue is empty!");
    }

    while (q1.size() > 1) {
        top = q1.remove();
        q2.add(top);
    }
    int res = q1.remove();

    Queue<Integer> temp = q1;
    q1 = q2;
    q2 = temp;

    return res;
}

复杂度分析如下：

  • 时间复杂度： O ( n ) O(n) O(n)，其中 n n n 表示未出栈前元素的数目。出栈操作需要从队列1 q1 出队 n n n 个元素，同时入队 n − 1 n-1 n−1 个元素到队列2 q2，因此需要 2 n − 1 2n - 1 2n−1 次操作。因此 LinkedList 的添加和删除操作的时间复杂度是 O ( 1 ) O(1) O(1) 的，因此，总的时间复杂度为 O ( n ) O(n) O(n)
  • 空间复杂度： O ( 1 ) O(1) O(1)

查看栈顶元素（peek）

因为我们用变量 top 保存了栈顶的元素，因此只需要返回该变量即可，代码（Java）实现如下：

/** Get the top element. */
public int top() {
    return top;
}

复杂度分析如下：

  • 时间复杂度： O ( 1 ) O(1) O(1)
  • 空间复杂度： O ( 1 ) O(1) O(1)

是否为空（empty）

队列1 q1 中保存了栈中的所有元素，因此，如果想要知道栈是否为空，只需要判断队列1 q1 中是否还有元素，代码（Java）实现如下：

/** Returns whether the stack is empty. */
public boolean empty() {
	return q1.isEmpty();
}

复杂度分析如下：

  • 时间复杂度： O ( 1 ) O(1) O(1)
  • 空间复杂度： O ( 1 ) O(1) O(1)

Java 实现

import java.util.NoSuchElementException;
import java.util.LinkedList;
import java.util.Queue;

class MyStack {

    /**
     * The main queue using to store all the elements in the stack
     */
    private Queue<Integer> q1;
    /**
     * The auxiliary queue using to implement `pop` operation
     */
    private Queue<Integer> q2;
    /**
     * The top element in the stack
     */
    private int top;

    /** Initialize your data structure here. */
    public MyStack() {
        q1 = new LinkedList<>();
        q2 = new LinkedList<>();
    }

    /** Push element x onto stack. */
    public void push(int x) {
        top = x;
        q1.add(x);
    }

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        if (q1.size() == 0) {
            throw new NoSuchElementException("[ERROR] The stack is empty!");
        }

        while (q1.size() > 1) {
            top = q1.remove();
            q2.add(top);
        }
        int res = q1.remove();

        Queue<Integer> temp = q1;
        q1 = q2;
        q2 = temp;

        return res;
    }

    /** Get the top element. */
    public int top() {
        return top;
    }

    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q1.isEmpty();
    }
}

Python 实现

from collections import deque

class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self._q1, self._q2, self._top = deque(), deque(), None
        

    def push(self, x):
        """
        Push element x onto stack.
        :type x: int
        :rtype: void
        """
        self._top = x
        self._q1.append(x)
        

    def pop(self):
        """
        Removes the element on top of the stack and returns that element.
        :rtype: int
        """
        if not self._q1:
            raise Exception("[ERROR] The stack is empty!")
            
        while len(self._q1) > 1:
            self._top = self._q1.popleft()
            self._q2.append(self._top)
        res = self._q1.popleft()
        
        self._q1, self._q2 = self._q2, self._q1
        return res
        

    def top(self):
        """
        Get the top element.
        :rtype: int
        """
        return self._top
        

    def empty(self):
        """
        Returns whether the stack is empty.
        :rtype: bool
        """
        return not self._q1

解法二：双队列，入慢出快

思路

与解法一相同的是，解法二也借助于两个队列。不同之处在于解法二在入栈时，已经在队列中将元素排列成出栈的顺序。因此，解法二实现的栈的入栈操作是 O ( n ) O(n) O(n) 的时间复杂度，而出栈操作则只需要 O ( 1 ) O(1) O(1) 的时间复杂度。相关操作的底层实现细节见下面对应的小节。

入栈（push）

为了使得队列1 q1 中的出队顺序和出栈顺序是一致的，需要借助另一个队列（辅助队列 q2）。每次有新的元素压入栈时，将该元素入队到队列2 q2 中。接着，将队列1 q1 中的所有元素出队并入队到队列2 q2 中。最后，再将两个队列的引用进行交换，则队列1 q1 中出队的顺序即为实际的出栈顺序。具体的操作步骤如图3所示。

在这里插入图片描述

图3：将一个元素压入栈

代码（Java）实现如下：

/** Push element x onto stack. */
public void push(int x) {
    q2.add(x);
    while (!q1.isEmpty()) {
        q2.add(q1.remove());
    }

    Queue<Integer> temp = q1;
    q1 = q2;
    q2 = temp;
}

复杂度分析如下：

  • 时间复杂度： O ( n ) O(n) O(n)，其中 n n n 表示入栈前元素的数目。入栈操作需要 n + 1 n+1 n+1 个入队操作，同时还需要 n n n 个出队操作，因此，总共需要 2 n + 1 2n + 1 2n+1 个操作。由于 LinkedList 的添加和删除操作的时间复杂度是 O ( 1 ) O(1) O(1) 的，因此，总的时间复杂度是 O ( n ) O(n) O(n) 的
  • 空间复杂度： O ( 1 ) O(1) O(1)

出栈（pop）

由于在入栈时已经将队列中的元素排列成出栈的顺序，因此，只需要出队队列1 q1 中队首的元素即可。

在这里插入图片描述

图4：将一个元素出栈

代码（Java）实现如下：

/** Removes the element on top of the stack and returns that element. */
public int pop() {
    if (q1.isEmpty()) {
        throw new NoSuchElementException("[ERROR] The stack is empty!");
    }

    return q1.remove();
}

复杂度分析如下：

  • 时间复杂度： O ( 1 ) O(1) O(1)
  • 空间复杂度： O ( 1 ) O(1) O(1)

查看栈顶元素（peek）

同理，只需要返回队列1 q1 队首元素即可。

/** Get the top element. */
public int top() {
    if (q1.isEmpty()) {
        throw new NoSuchElementException("[ERROR] The stack is empty!");
    }

    return q1.peek();
}

复杂度分析如下：

  • 时间复杂度： O ( 1 ) O(1) O(1)
  • 空间复杂度： O ( 1 ) O(1) O(1)

是否为空（empty）

这个操作和解法一的没什么不同，故不再赘言。

Java 实现

import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Queue;

class MyStack {
    private Queue<Integer> q1;
    private Queue<Integer> q2;

    /** Initialize your data structure here. */
    public MyStack() {
        q1 = new LinkedList<>();
        q2 = new LinkedList<>();
    }

    /** Push element x onto stack. */
    public void push(int x) {
        q2.add(x);
        while (!q1.isEmpty()) {
            q2.add(q1.remove());
        }

        Queue<Integer> temp = q1;
        q1 = q2;
        q2 = temp;
    }

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        if (q1.isEmpty()) {
            throw new NoSuchElementException("[ERROR] The stack is empty!");
        }

        return q1.remove();
    }

    /** Get the top element. */
    public int top() {
        if (q1.isEmpty()) {
            throw new NoSuchElementException("[ERROR] The stack is empty!");
        }

        return q1.peek();
    }

    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q1.isEmpty();
    }
}

Python 实现

from collections import deque

class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self._q1, self._q2 = deque(), deque()
        

    def push(self, x):
        """
        Push element x onto stack.
        :type x: int
        :rtype: void
        """
        self._q2.append(x)
        while self._q1:
            self._q2.append(self._q1.popleft())
        self._q1, self._q2 = self._q2, self._q1
        

    def pop(self):
        """
        Removes the element on top of the stack and returns that element.
        :rtype: int
        """
        if not self._q1:
            raise Exception("[ERROR] The stack is empty!")
        return self._q1.popleft()

    def top(self):
        """
        Get the top element.
        :rtype: int
        """
        if not self._q1:
            raise Exception("[ERROR] The stack is empty!")
        return self._q1[0]
        

    def empty(self):
        """
        Returns whether the stack is empty.
        :rtype: bool
        """
        return not self._q1

解法三：单队列

思路

上面两种解法都借助于两个队列，实际上，只借助于一个队列也可以实现栈的先入先出效果。

入栈（push）

入栈时，新添加的元素位于队列的队尾，但是对于栈而言，它其实是栈顶元素。为了使得新添加的元素位于队首，可以将其之前的所有元素出队并重新入队。最终，队列中元素的顺序和出栈的顺序是一致的。具体的操作步骤如下图所示。

在这里插入图片描述

图5：将一个元素压入栈

代码（Java）实现如下：

/** Push element x onto stack. */
public void push(int x) {
    queue.add(x);
    for (int i = 0; i < queue.size() - 1; ++i) {
        queue.add(queue.remove());
    }
}

复杂度分析：

  • 时间复杂度： O ( n ) O(n) O(n)，其中 n n n 表示入栈前栈内元素的数目。入栈操作需要 n n n 次的出队操作，同时也需要 n + 1 n + 1 n+1次的入队操作，因此，需要总的操作次数为 2 n + 1 2n + 1 2n+1 次。由于 LinkedList 的添加和删除操作的时间复杂度是 O ( 1 ) O(1) O(1) 的，因此，总的时间复杂度为 O ( n ) O(n) O(n)
  • 空间复杂度： O ( 1 ) O(1) O(1)

出栈（pop）

由于在入栈时已经将队列中的元素排列成出栈的顺序，因此，只需要出队队列 q1 中队首的元素即可。

在这里插入图片描述

图6：将一个元素出栈

代码（Java）实现如下：

/** Removes the element on top of the stack and returns that element. */
public int pop() {
    if (queue.isEmpty()) {
        throw new NoSuchElementException("[ERROR] The stack is empty!");
    }

    return queue.remove();
}

复杂度分析如下：

  • 时间复杂度： O ( 1 ) O(1) O(1)
  • 空间复杂度： O ( 1 ) O(1) O(1)

查看栈顶元素（peek）

同理，只需要返回队列 q1 的队首元素即可。

/** Get the top element. */
public int top() {
    if (queue.isEmpty()) {
        throw new NoSuchElementException("[ERROR] The stack is empty!");
    }

    return queue.peek();
}

复杂度分析如下：

  • 时间复杂度： O ( 1 ) O(1) O(1)
  • 空间复杂度： O ( 1 ) O(1) O(1)

是否为空（empty）

队列 q1 中保存了栈中的所有元素，因此，如果想要知道栈是否为空，只需要判断队列 q1 中是否还有元素，代码（Java）实现如下：

/** Returns whether the stack is empty. */
public boolean empty() {
    return queue.isEmpty();
}

复杂度分析如下：

  • 时间复杂度： O ( 1 ) O(1) O(1)
  • 空间复杂度： O ( 1 ) O(1) O(1)

Java 实现

import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Queue;

class MyStack {
    private Queue<Integer> queue;

    /** Initialize your data structure here. */
    public MyStack() {
        queue = new LinkedList<>();
    }

    /** Push element x onto stack. */
    public void push(int x) {
        queue.add(x);
        for (int i = 0; i < queue.size() - 1; ++i) {
            queue.add(queue.remove());
        }
    }

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        if (queue.isEmpty()) {
            throw new NoSuchElementException("[ERROR] The stack is empty!");
        }

        return queue.remove();
    }

    /** Get the top element. */
    public int top() {
        if (queue.isEmpty()) {
            throw new NoSuchElementException("[ERROR] The stack is empty!");
        }

        return queue.peek();
    }

    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue.isEmpty();
    }
}

/**
 * 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();
 * boolean param_4 = obj.empty();
 */

Python 实现

from collections import deque

class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self._q = deque()
        

    def push(self, x):
        """
        Push element x onto stack.
        :type x: int
        :rtype: void
        """
        self._q.append(x)
        for _ in range(len(self._q) - 1):
            self._q.append(self._q.popleft())
        

    def pop(self):
        """
        Removes the element on top of the stack and returns that element.
        :rtype: int
        """
        if not self._q:
            raise Exception("[ERROR] The stack is empty!")
        return self._q.popleft()

    def top(self):
        """
        Get the top element.
        :rtype: int
        """
        if not self._q:
            raise Exception("[ERROR] The stack is empty!")
        return self._q[0]
        

    def empty(self):
        """
        Returns whether the stack is empty.
        :rtype: bool
        """
        return not self._q
python实现栈的操作_python简单实现队列和栈push、pop操作
weixin_39991222的博客
11-28 1165
栈：# -*- coding: utf-8 -*-#定义序列lst=[]def pop():if(len(lst)==0):print"栈为空","无法出栈"else:print "此次出栈元素为：",lst.pop()def push(i):lst.append(i)push(1)push(2)push(3)pop()pop()pop()pop()队列：# -*- coding: utf-8 -...
LeetCode详细题解答案整理-java
qq_41878358的博客
02-16 1657
LeetCode详细题解答案整理 1 Two Sum 两数之和 Two Sum 两数之和 Easy Array，HashTable 7 Reverse Integer 颠倒整数 Reverse Integer 颠倒整数 Easy Math 9 Palindrome Number 回文数 Palindrome Number ...
【leetcode刷题】[简单]225. 用队列实现栈（implement stack using queues）-java
mikuluna的博客
12-31 173
用队列实现栈 implement stack using queues题目分析解答 题目 使用队列实现栈的下列操作： push(x) – 元素 x 入栈 pop() – 移除栈顶元素 top() – 获取栈顶元素 empty() – 返回栈是否为空 注意: 你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is emp...
leetcode 225 Implement Stack using Queues 用队列实现栈 python 双队列
Jasmine_dream
04-20 231
所有Leetcode题目不定期汇总在 Github, 欢迎大家批评指正，讨论交流。 ''' Implement the following operations of a stack using queues. push(x) -- Push element x onto stack. pop() -- Removes the element on top of the stack. top...
[LeetCode]225. Implement Stack using Queues
砥砺前行的博客
11-01 530
Implement the following operations of a stack using queues. push(x) -- Push element x onto stack. pop() -- Removes the element on top of the stack. top() -- Get the top element. empty() -- Return whet...
Implement Queue by Two Stacks 解题报告
总结沉淀
04-26 898
Implement Queue by Two StacksDescriptionAs the title described, you should only use two stacks to implement a queue’s actions.The queue should support push(element), pop() and top() where pop is pop th
python-leetcode题解之225-Implement-Stack-using-Queues.py
09-12
python python_leetcode题解之225_Implement_Stack_using_Queues.py
java-leetcode面试题解Stack之第225题用队列实现栈-题解.zip
05-05
这道题目是LeetCode中的第225题，名为"用队列实现栈"（Implement Stack using Queues）。在这个问题中，我们需要使用两个队列来模拟栈的数据结构和操作，主要包含`push`、`pop`和`top`等基本功能。 栈是一种后进先...
java-leetcode题解之Implement Stack using Queues.java
最新发布
10-08
java java_leetcode题解之Implement Stack using Queues.java
十进制转二进制（顺序栈设计和应用） 设计一个顺序栈，并利用该顺序栈将给定的十进制整整数转换为二进制并输出。
weixin_45385429的博客
11-13 5015
/* 栈顶指针 */ int mystack[MaxSize]; /* 顺序栈 */ /*判栈是否为空，空返回true，非空返回false */ bool isEmpty(); /* 元素x入栈 */ void Push(int x); /* 取栈顶元素 */ int getTop(); /* 删除栈顶元素 */ void Pop(); 其中 MaxSize 和 top 分别为栈的最大容量和栈顶指针。数组mystack 用来模拟顺序栈。请实现给出的isEmpty、Push、getTop和Po...
【C语言】实现数据结构——栈，队列
weixin_45423515的博客
05-18 2308
栈和队列都常用的数据结构，这里使用C语言实现栈和队列， 一、栈 栈：是一种特殊的线性表，其只允许在一端出数据和入数据，插入数据和删除数据的一端加栈顶，另一端叫栈底。其数据遵守先进后出的原则（Last in First out）。 因为这个特点那么如果进入一段数据是 1 2 3 4 5，那么其出数据就是反的 5 4 3 2 1。 压栈(push):往栈顶插入数据。 出栈(pop):把数据在栈顶删除。 实现： typedef int STdatatype; typedef...
数据结构第三章栈和队列
amdkk的博客
11-25 324
栈和队列是两种重要的线性结构，也是线性表，是操作受限的线性表；从数据类型的角度看，他们是和线性表不相同的抽象数据类型 栈 限定仅在表尾进行插入或删除操作的线性表 表尾称为栈顶，表头称为栈底，退栈的第一个元素为栈顶元素，故称为后进先出的线性表 顺序栈：用顺序表实现的栈 1.定义 #define MAXSIZE 100 typedef struct{ SElemType *top; SElemType *base; int stacksize; }SqStack; 2.初
C++ 链式栈（使用模板类）
ChanJose的博客
01-08 1134
一、实现程序： 1.Stack.h #ifndef Stack_h #define Stack_h template &lt;class T&gt; class Stack { public: Stack(){}; // 构造函数 void Push(const T x); // 新元素进栈 bool Pop(); // 栈顶元素出栈 virtual boo...
【LeetCode题解】347_前K个高频元素（Top-K-Frequent-Elements）
StrongXGP 的博客
11-13 2518
更多 LeetCode 题解笔记可以访问我的 github。 文章目录描述解法一：排序算法（不满足时间复杂度要求）Java 实现Python 实现复杂度分析解法二：最小堆思路Java 实现Python 实现复杂度分析解法三：桶排序（bucket sort）思路Java 实现Python 实现复杂度分析 描述 给定一个非空的整数数组，返回其中出现频率前 k 高的元素。 示例 1: 输入: num...
【LeetCode题解】142_环形链表2（Linked-List-Cycle-II）
StrongXGP 的博客
11-06 396
文章目录描述解法一：哈希表思路Java 实现Python 实现复杂度分析解法二：双指针思路Java 实现Python 实现复杂度分析 描述 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 **说明：**不允许修改给定的链表。 进阶： 你是否可以不用额外空间解决此题？ 解法一：哈希表 思路 最直接的解法就是利用一个集合保存每次遍历的节点的引用。之后，从链表头开始遍历，...
【LeetCode题解】169_求众数（Majority-Element）
StrongXGP 的博客
10-31 395
169_求众数（Majority-Element） 这道题有 5 种方法，8 种实现，详细分析可以看花花酱的 YouTube 专栏。 文章目录169_求众数（Majority-Element）描述解法一：暴力法思路Java 实现Python 实现复杂度分析解法二：哈希表思路Java 实现Python 实现复杂度分析解法三：排序Java 实现Python 实现复杂度分析解法四：随机选择【待完成...
【LeetCode题解】844_比较含退格的字符串（Backspace-String-Compare）
StrongXGP 的博客
11-29 315
更多 LeetCode 题解笔记可以访问我的 github。 文章目录描述解法一：字符串比较思路Java 实现Python 实现复杂度分析解法二：双指针（推荐）思路Java 实现Python 实现复杂度分析 描述 给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。 示例 1： 输入：S = &quot;ab#c&quot;, T = &quot;ad#c&quot;...
C语言实现二叉树中序遍历-LeetCode题解
资源摘要信息:"c语言-leetcode题解之0094-binary-tree-inorder-traversal.zip" 在深入探讨这个资源之前，我们需要理解几个关键的概念：C语言、leetcode以及二叉树的中序遍历。 C语言是一种广泛使用的高级编程语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值