【91alg-16-daily-take a look into it】用栈实现队列的完整解题思路与代码解析—LeetCode第232题详解

阿正

5个月前发布

14150

232. 用栈实现队列

入选理由

暂无

题目地址

https://leetcode-cn.com/problems/implement-queue-using-stacks/

前置知识

栈
队列

题目描述

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

push(x) -- 将一个元素放入队列的尾部。
pop() -- 从队列首部移除元素。
peek() -- 返回队列首部的元素。
empty() -- 返回队列是否为空。
示例:

MyQueue queue = new MyQueue();

queue.push(1);
queue.push(2);
queue.peek(); // 返回 1
queue.pop(); // 返回 1
queue.empty(); // 返回 false
说明:

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

文章版权归作者所有，未经允许请勿转载。如内容涉嫌侵权，请在本页底部进入<联系我们>进行举报投诉!

THE END

知识分享

如果内容对您有所帮助,就支持一下吧!

随机推荐

评论共14条

请登录后发表评论

登录注册

只看作者

沉睡海洋

push操作：输入栈入栈
pop操作：如果输出栈不为空，则直接输出输出栈的元素。如果输出栈为空，则把输入栈的数据全部导入到输出栈中
peek操作：如果输出栈不为空，则直接peek输出栈的元素。如果输出栈为空，则把输入栈的数据全部导出到输入栈中

class MyQueue {    Stack<Integer> stackIn;    Stack<Integer> stackOut;    public MyQueue() {        stackIn = new Stack<>();        stackOut = new Stack<>();    }        public void push(int x) {        stackIn.push(x);    }        public int pop() {        refresh();        return stackOut.pop();    }        public int peek() {        refresh();        return stackOut.peek();    }        public boolean empty() {        return stackIn.isEmpty() && stackOut.isEmpty();    }    public void refresh(){        if(!stackOut.isEmpty()){            return;        }        while(!stackIn.isEmpty()){            stackOut.push(stackIn.pop());        }    }}

5个月前回复举报


武汉潘唯杰0
算法设计
加入队尾 push() ： 将数字 val 加入栈 A 即可。
获取队首元素 peek() ：
当栈 B 不为空： B中仍有已完成倒序的元素，因此直接返回 B 的栈顶元素。
否则，当 A 为空： 即两个栈都为空，无元素，因此返回 -1 。
否则： 将栈 A 元素全部转移至栈 B 中，实现元素倒序，并返回栈 B 的栈顶元素。
弹出队首元素 pop() ：
执行 peek() ，获取队首元素。
弹出 B 的栈顶元素。
队列判空 empty() ： 当栈 A 和 B 都为空时，队列为空。
class MyQueue:
def __init__(self):    self.A, self.B = [], []def push(self, x: int) -> None:    self.A.append(x)def pop(self) -> int:    peek = self.peek()    self.B.pop()    return peekdef peek(self) -> int:    if self.B: return self.B[-1]    if not self.A: return -1    # 将栈 A 的元素依次移动至栈 B    while self.A:        self.B.append(self.A.pop())    return self.B[-1]def empty(self) -> bool:    return not self.A and not self.B      Your MyQueue object will be instantiated and called as such:
obj = MyQueue()
obj.push(x)
param_2 = obj.pop()
param_3 = obj.peek()
param_4 = obj.empty()
时间复杂度： push(), empty() 函数的时间复杂度为 O(1) ；peek() , pop() 函数在 N 次队首元素删除操作中总共需完成 N 个元素的倒序，均摊时间复杂度为 O(1) 。
5个月前回复举报

心一如镜0
核心算法思路
使用两个栈实现队列：
inStack: 用于接收新元素的输入
outStack: 用于输出元素
当需要 pop 或 peek 时，如果 outStack 为空，就将 inStack 中的所有元素转移到 outStack 中，这样就实现了先入先出的特性。
代码实现var MyQueue = function() {    this.inStack = [];     用于输入的栈    this.outStack = [];    用于输出的栈}; **  * @param {number} x * @return {void} * MyQueue.prototype.push = function(x) {    this.inStack.push(x);}; ** * @return {number} * MyQueue.prototype.pop = function() {    if (this.outStack.length === 0) {           将inStack中的所有元素转移到outStack        while (this.inStack.length > 0) {            this.outStack.push(this.inStack.pop());        }    }    return this.outStack.pop();}; ** * @return {number} * MyQueue.prototype.peek = function() {    if (this.outStack.length === 0) {           将inStack中的所有元素转移到outStack        while (this.inStack.length > 0) {            this.outStack.push(this.inStack.pop());        }    }    return this.outStack[this.outStack.length - 1];}; ** * @return {boolean} * MyQueue.prototype.empty = function() {    return this.inStack.length === 0 && this.outStack.length === 0;}; **  * Your MyQueue object will be instantiated and called as such: * var obj = new MyQueue() * obj.push(x) * var param_2 = obj.pop() * var param_3 = obj.peek() * var param_4 = obj.empty() *       复杂度分析
时间复杂度：
push: O(1)
pop: 均摊 O(1)
peek: 均摊 O(1)
empty: O(1)
空间复杂度: O(n)
均摊 O(1) 的原理：虽然单次 pop 或 peek 操作在最坏情况下可能需要 O(n) 时间，但每个元素最多只会被转移一次，所以 n 个操作的总时间复杂度为 O(n)，均摊下来每个操作为 O(1)。
5个月前回复举报

耶耶的生椰拿铁0
【Day 5】232. 用栈实现队列
思路
利用栈先进后出的性质,通过stack1完成元素的倒序放置,再将stack1的元素放入stack2中,前面的元素就放在了栈顶. 此时经过两次入栈出栈的操作stack2中的元素就满足了先进先出的要求.
但是要注意以下问题:
只有在stack2中元素为空时才能将stack1中的元素放入stack2中,这样才能保证有序性
遍历list元素要使用while, 不能用for,否则会有元素被跳过
代码
class MyQueue(object):    def __init__(self):        self.stack1, self.stack2 = [], []            def push(self, x):        """        :type x: int        :rtype: None        """        self.stack1.append(x)            def pop(self):        """        :rtype: int        """        res = self.peek()        return self.stack2.pop()            def peek(self):        """        :rtype: int        """        if self.stack2:            return self.stack2[-1]        elif self.stack1:            while self.stack1:                self.stack2.append(self.stack1.pop())            return self.stack2[-1]        else:            return -1            def empty(self):        """        :rtype: bool        """        return not self.stack1 and not self.stack2        # Your MyQueue object will be instantiated and called as such:# obj = MyQueue()# obj.push(x)# param_2 = obj.pop()# param_3 = obj.peek()# param_4 = obj.empty()      复杂度分析
时间复杂度: push, empty 是O(1), pop, peek是O(N)
空间复杂度: O(N)
5个月前回复举报

教资教师编备考0
使用兩個 stack：
in_stack: 用來接收 push
out_stack: 用來處理 pop 和 peek
當 out_stack 為空時，將 in_stack 的所有元素彈出並倒序放入 out_stack，用來模擬 queue 的 FIFO
push：O(1)
pop：O(1)
peek：O(1)
empty ：O(1)
Python code
class MyQueue:    def __init__(self):        self.in_stack = []        self.out_stack = []    def push(self, x: int) -> None:        self.in_stack.append(x)    def pop(self) -> int:        self.peek()  # 確保 out_stack 有東西        return self.out_stack.pop()    def peek(self) -> int:        if not self.out_stack:            while self.in_stack:                self.out_stack.append(self.in_stack.pop())        return self.out_stack[-1]    def empty(self) -> bool:        return not self.in_stack and not self.out_stack      
5个月前回复举报

公主殿下0
思路：
通过元素在栈之间的转移来模拟队列的先进先出。
class MyQueue:    """使用两个栈实现的队列类"""    def __init__(self):        # 初始化两个栈：stack_in 用于入队操作，stack_out 用于出队操作        self.stack_in = []        self.stack_out = []    def push(self, x: int) -> None:        """将元素 x 添加到队列的尾部        直接将元素压入 stack_in        """        self.stack_in.append(x)    def pop(self) -> int:        """移除并返回队列头部的元素        1. 如果 stack_out 为空，将 stack_in 中的所有元素弹出并压入 stack_out        2. 这样能确保元素以先进先出的顺序出栈        3. 弹出 stack_out 的栈顶元素        """        if not self.stack_out:            while self.stack_in:                self.stack_out.append(self.stack_in.pop())        return self.stack_out.pop()    def peek(self) -> int:        """返回队列头部的元素，但不删除它        复用 pop 方法获取队首元素，然后将其压回 stack_out 以保持队列状态不变        """        res = self.pop()        self.stack_out.append(res)        return res    def empty(self) -> bool:        """检查队列是否为空        当且仅当两个栈都为空时，队列为空        """        return not (self.stack_in or self.stack_out)      
5个月前回复举报

愉悦罐头实验室0
Main Idea
We can use stack1 as the input stack, and stack2 as the output stack.
push(): Push to stack1, so this new element will be on the stack top of stack1 (which is the end of our queue).
pop() and peek(): Since we use stack2 as our output stack, when we call pop() or peek():
If stack2 is empty, we want to move all elements from stack1 to stack2, and their order will be reversed, so the bottom of stack1 will be the top of stack2, which is the head of our queue.
If not, then we have access to the top of stack2 already.
Codeclass MyQueue {    Deque<Integer> stack1;    Deque<Integer> stack2;        public MyQueue() {        stack1 = new ArrayDeque<>();        stack2 = new ArrayDeque<>();    }        public void push(int x) {        stack1.push(x);    }        public int pop() {        if (stack2.isEmpty()) {            move();        }        return stack2.pop();    }        public int peek() {        if (stack2.isEmpty()) {            move();        }                return stack2.peek();    }        public boolean empty() {        return stack1.isEmpty() && stack2.isEmpty();    }        private void move() {        while (!stack1.isEmpty()) {            stack2.push(stack1.pop());        }    }}      Complexity Analysis
Time:
push(): O(1)
pop() and peek():The worst case of pop() and peek() will be O(n), where we have to move all elements from stack1 to stack2.
Amortized Analysis: Say we have n elements in stack1, and 0 elements in stack2, and we want to call pop() or peek() n times. The first call will take n operations to move all elements from stack2 to stack1. But after the first call we will have at least n - 1 elemetns in stack2, which makes the next n - 1 calls  O(1). So the amrotized time will be O(n + 1 + 1 +...+1   n) = O((2n-1) n) = O(1).
Space: O(1), the two stacks are given and we didn t use any extra spaces.
5个月前回复举报

活死人0
思路
push和empty可以直接进行操作。
pop和 peek需要得到入栈的第一个元素，可以使用一个辅助栈，对第一个栈进行出栈同时第二个栈进行入栈操作，这样第二个栈top得到的元素就是第一个栈入栈的第一个元素。
class MyQueue {public:    stack<int> tmp;    stack<int> stack;    MyQueue() {    }        void push(int x) {        tmp.push(x);    }        int pop() {        while(!tmp.empty()){            stack.push(tmp.top());            tmp.pop();        }        int a = stack.top();        stack.pop();        while(!stack.empty()){            tmp.push(stack.top());            stack.pop();        }        return a;    }        int peek() {        while(!tmp.empty()){            stack.push(tmp.top());            tmp.pop();        }        int a = stack.top();        while(!stack.empty()){            tmp.push(stack.top());            stack.pop();        }        return a;    }        bool empty() {        return tmp.empty();    }}; ** * Your MyQueue object will be instantiated and called as such: * MyQueue* obj = new MyQueue(); * obj->push(x); * int param_2 = obj->pop(); * int param_3 = obj->peek(); * bool param_4 = obj->empty(); *       
5个月前回复举报

二次元时光机0
用两个模拟栈的队列来实现栈的基本操作。一个用于添加尾部元素，另一个用于弹出头部元素。即一个近栈stack in和一个出栈stack out。
class MyQueue:    def __init__(self):        """        in主要负责push，out主要负责pop        """        self.stack_in = []        self.stack_out = []    def push(self, x: int) -> None:        """        有新元素进来，就往in里面push        """        self.stack_in.append(x)    def pop(self) -> int:        """        Removes the element from in front of queue and returns that element.        """        if self.empty():            return None                if self.stack_out:            return self.stack_out.pop()        else:            for i in range(len(self.stack_in)):                self.stack_out.append(self.stack_in.pop())            return self.stack_out.pop()    def peek(self) -> int:        """        Get the front element.        """        ans = self.pop()        self.stack_out.append(ans)        return ans    def empty(self) -> bool:        """        只要in或者out有元素，说明队列不为空        """        return not (self.stack_in or self.stack_out)      时间复杂度：
push 操作的时间复杂度是 O(1)，由于我们只是将元素添加到 stack_in 的末尾。
pop 和 peek 操作的平均时间复杂度是 O(1)，但在最坏情况下（当 stack_out 为空时），需要将 stack_in 中的所有元素转移到 stack_out，这需要 O(n) 的时间，其中 n 是 stack_in 中的元素数量。不过，这种情况不会频繁发生，因此平均时间复杂度依旧是 O(1)。
empty 操作的时间复杂度是 O(1)，由于我们只是检查两个栈是否为空。
空间复杂度是 O(n)，其中 n 是队列中的元素数量，由于我们需要存储所有元素在两个栈中。
但是我有个问题，不知道为什么用lc自己的time complexity分析出来是O(n)的时间和空间复杂度，可能是由于lc的分析是基于最坏情况的分析？
5个月前回复举报

国外直播福利0
思路
设计双栈，一个用于存放入队数据，一个用于存放出队数据。
各个操作的实现思路：push：将数据压入pushData栈中。
pop：如果popData栈为空，则将pushData栈中的数据全部弹出并压入popData栈中。然后弹出popData栈的栈顶元素。
peek：同pop操作，最后一步返回popData栈的栈顶元素。
empty：判断两个栈是否为空。
js中可以用数组模拟栈。
代码
var MyQueue = function() {   this.pushData = []   this.popData = [] }; **  * @param {number} x * @return {void} * MyQueue.prototype.push = function(x) {    this.pushData.push(x)    }; ** * @return {number} * MyQueue.prototype.pop = function() {    if(this.popData.length === 0 && this.pushData.length) while(this.pushData.length) this.popData.push(this.pushData.pop());    return this.popData.pop();}; ** * @return {number} * MyQueue.prototype.peek = function() {    if(this.popData.length === 0 && this.pushData.length) while(this.pushData.length) this.popData.push(this.pushData.pop());    return this.popData[this.popData.length - 1];}; ** * @return {boolean} * MyQueue.prototype.empty = function() {    return this.pushData.length === 0 && this.popData.length === 0}; **  * Your MyQueue object will be instantiated and called as such: * var obj = new MyQueue() * obj.push(x) * var param_2 = obj.pop() * var param_3 = obj.peek() * var param_4 = obj.empty() *       复杂度分析
时间复杂度：O(1)：插入、删除、查找操作的均摊时间复杂度都是O(1)
空间复杂度：O(n)：栈的存储空间
5个月前回复举报

新世界的小屁孩0
思維一：以暴力解的方式在 peek 或 pop 的操作時，用另一個陣列依序存目前 stack pop 出來的所有元素，操作結果後再依序新增回去，時間及空間複雜度皆為 O(N)（無實作）

思維二：使用兩個 stack 來操作存取，當有  peek 或 pop 的操作時，從 out_stack 拿取，判斷 out_stack 為空時再一次性的把當前 in_stack 的所有元素倒進 out_stack
代碼：
class MyQueue(object):    def __init__(self):        self.in_stack = []        self.out_stack = []            def push(self, x):        """        :type x: int        :rtype: None        """        self.in_stack.append(x)            def pop(self):        """        :rtype: int        """        if not self.out_stack:            while self.in_stack:                self.out_stack.append(self.in_stack.pop())        return self.out_stack.pop()            def peek(self):        """        :rtype: int        """        if not self.out_stack:            while self.in_stack:                self.out_stack.append(self.in_stack.pop())        return self.out_stack[-1]            def empty(self):        """        :rtype: bool        """        return not (self.in_stack + self.out_stack)      時間複雜度：O(1) (Amortized)
空間複雜度：O(N)
5个月前回复举报

汤司令0
透過第二個 stack 倒轉第一個 in-stack 的順序，以達到 FIFO 的效果
   Time Complexity: O(1) for push, pop, peek, empty;   Space Complexity: O(n)class MyQueue {    constructor() {        this.inStack = [];        this.outStack = [];    }     **      * @param {number} x     * @return {void}     *     push(x) {        this.inStack.push(x);    }     **     * @return {number}     *     pop() {        if (!this.outStack.length) {            this.pushToOutStack();        }        return this.outStack.pop();    }     **     * @return {number}     *     peek() {        if (!this.outStack.length) {            this.pushToOutStack();        }        return this.outStack[this.outStack.length - 1];    }     **     * @return {boolean}     *     empty() {        return this.peek() === undefined;    }    pushToOutStack() {        while (this.inStack.length) {            this.outStack.push(this.inStack.pop());        }    }}      
5个月前回复举报

江晓满0
js代码
var MyQueue = function() {    this.inStack = [];    this.outStack = [];};MyQueue.prototype.push = function(x) {    this.inStack.push(x);};MyQueue.prototype.pop = function() {    if (!this.outStack.length) {        this.in2out();    }    return this.outStack.pop();};MyQueue.prototype.peek = function() {    if (!this.outStack.length) {        this.in2out();    }    return this.outStack[this.outStack.length - 1];};MyQueue.prototype.empty = function() {    return this.outStack.length === 0 && this.inStack.length === 0;};MyQueue.prototype.in2out = function() {    while (this.inStack.length) {        this.outStack.push(this.inStack.pop());    }};      复杂度分析
时间复杂度：O(1)
空间复杂度：O(n)
5个月前回复举报

H梵莲0
思路：用两个栈模拟操作，在 peek 的时候出第二个栈的顶部即可
var MyQueue = function() {    this.a = [];    this.b = [];}; **  * @param {number} x * @return {void} * MyQueue.prototype.push = function(x) {    this.a.push(x);}; ** * @return {number} * MyQueue.prototype.pop = function() {    this.peek();    return this.b.pop();}; ** * @return {number} * MyQueue.prototype.peek = function() {    if (this.b.length) {        return this.b[this.b.length - 1]    } else {        while(this.a.length) {            this.b.push(this.a.pop())        }        return this.peek()    }}; ** * @return {boolean} * MyQueue.prototype.empty = function() {    return !this.a.length && !this.b.length}; **  * Your MyQueue object will be instantiated and called as such: * var obj = new MyQueue() * obj.push(x) * var param_2 = obj.pop() * var param_3 = obj.peek() * var param_4 = obj.empty() *       
5个月前回复举报

阿正关注 7440204 以知识为马，带你驶向未来的彼岸... 公众号附件怎么添加文档 css基础理论（对齐，组合选择符，伪类，伪元素，导航栏，下拉菜单，提示工具，图片廊，图片透明/不透明，图像拼合技术，媒体类型，属性选择器，表单，计数器，网页布局）微信聊天背景‖翠脆集 3.4W+人已阅读《困困兔》无删减免费在线观看全集1080p高清零广告_《困困兔寝室三部...TOP1 热门视频《bj女团熊猫班全员卸甲》免费观看_《bj女团熊猫班全员卸甲》无删减版 HD 高清在线观看_《bj女团熊猫班全员卸甲》全集免费观看，《bj女团熊猫班全员卸甲》全集在线播放 – 西瓜影视网… 6个月前2.9W+人已阅读 TOP2 《完全堕落》家人被奇异睡眠笼罩的谜题动漫全集在线观赏-《完全堕落》家人陷入长眠动漫全两季免费观看西瓜视频在线点播-探寻家人沉睡真相动漫双季2025 年最疯动漫！把家人「睡」个遍还不够，这尺度居然能播？ 6个月前2.1W+人已阅读 TOP3 3个方法，教你如何设置 Windows 10/11 自动登录，一键直达桌面 1年前1.4W+人已阅读 TOP4 《小舞》3DMAX小舞全集在线播放_小舞3D动画高清完整版免费观看_小舞遇险记3D漫画无删减_1080P超清画质流畅播放-VS影视 6个月前8289人已阅读 TOP5 美国科幻:《铁血战士:杀戮之王》(2025)【4K超高清SDR中英字幕】免费在线观看播放夸克网盘资源下载《铁血战士:杀戮之王》–穿越千年的狩猎盛宴，重写人类与异星猎手的宿命对决 6个月前6925人已阅读 TOP6 签到领取今日奖励 TOP1 caoyuling 以知识为马，带你驶向未来的彼岸... 4197 TOP2 那年夏天店分享不止，创意无限，欢迎光临! 1562 TOP3 品牌推荐大师以知识为马，带你驶向未来的彼岸... 1533 TOP4 aw285990 个性随时更改 1293 TOP5 冰心之无忧以知识为马，带你驶向未来的彼岸... 535 TOP6 a285990 以知识为马，带你驶向未来的彼岸... 498 《困困兔》无删减免费在线观看全集1080p高清零广告_《困困兔寝室三部曲》完整夸克/迅雷网盘极速下载播放–《困困兔3》从深夜泡面到无声星河——一间大学宿舍直播间如何成为万千孤独灵魂的悬浮锚点知识分享 6个月前03.4W+21 热门视频《bj女团熊猫班全员卸甲》免费观看_《bj女团熊猫班全员卸甲》无删减版 HD 高清在线观看_《bj女团熊猫班全员卸甲》全集免费观看，《bj女团熊猫班全员卸甲》全集在线播放 – 西瓜影视网… 知识分享 6个月前02.9W+7 《完全堕落》家人被奇异睡眠笼罩的谜题动漫全集在线观赏-《完全堕落》家人陷入长眠动漫全两季免费观看西瓜视频在线点播-探寻家人沉睡真相动漫双季2025 年最疯动漫！把家人「睡」个遍还不够，这尺度居然能播？知识分享 6个月前02.1W+5 3个方法，教你如何设置 Windows 10/11 自动登录，一键直达桌面知识分享 1年前41.4W+1 《小舞》3DMAX小舞全集在线播放_小舞3D动画高清完整版免费观看_小舞遇险记3D漫画无删减_1080P超清画质流畅播放-VS影视知识分享 6个月前082892 美国科幻:《铁血战士:杀戮之王》(2025)【4K超高清SDR中英字幕】免费在线观看播放夸克网盘资源下载《铁血战士:杀戮之王》–穿越千年的狩猎盛宴，重写人类与异星猎手的宿命对决知识分享 6个月前069251 龚成思龙门县龙辉龙泉站龙族前传龙口市忠证基因龙口市亲子鉴定齐玉苓案鼻血的教训鼓励非公有制经济黔东南亲子鉴定机构黔东南亲子鉴定中心黔东南亲子鉴定黑龙江省长黑龙江省教育厅厅长黑龙江省司法厅黑话律师黑袍纠察队黑暗转向黑暗荣耀

【91alg-16-daily-take a look into it】用栈实现队列的完整解题思路与代码解析—LeetCode第232题详解

232. 用栈实现队列

入选理由

题目地址

前置知识

题目描述

请登录后发表评论

Your MyQueue object will be instantiated and called as such:

obj = MyQueue()

obj.push(x)

param_2 = obj.pop()

param_3 = obj.peek()

param_4 = obj.empty()

时间复杂度： push(), empty() 函数的时间复杂度为 O(1) ；peek() , pop() 函数在 N 次队首元素删除操作中总共需完成 N 个元素的倒序，均摊时间复杂度为 O(1) 。

核心算法思路

复杂度分析

Python code

思路：

Main Idea

Complexity Analysis

思路

思路

代码

复杂度分析

时间复杂度：O(1)：插入、删除、查找操作的均摊时间复杂度都是O(1)空间复杂度：O(n)：栈的存储空间

js代码

复杂度分析

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

《困困兔》无删减免费在线观看全集1080p高清零广告_《困困兔寝室三部曲》完整夸克/迅雷网盘极速下载播放–《困困兔3》从深夜泡面到无声星河——一间大学宿舍直播间如何成为万千孤独灵魂的悬浮锚点

热门视频《bj女团熊猫班全员卸甲》免费观看_《bj女团熊猫班全员卸甲》无删减版 HD 高清在线观看_《bj女团熊猫班全员卸甲》全集免费观看，《bj女团熊猫班全员卸甲》全集在线播放 – 西瓜影视网…

《完全堕落》家人被奇异睡眠笼罩的谜题动漫全集在线观赏-《完全堕落》家人陷入长眠动漫全两季免费观看西瓜视频在线点播-探寻家人沉睡真相动漫双季2025 年最疯动漫！把家人「睡」个遍还不够，这尺度居然能播？

3个方法，教你如何设置 Windows 10/11 自动登录，一键直达桌面

《小舞》3DMAX小舞全集在线播放_小舞3D动画高清完整版免费观看_小舞遇险记3D漫画无删减_1080P超清画质流畅播放-VS影视

美国科幻:《铁血战士:杀戮之王》(2025)【4K超高清SDR中英字幕】免费在线观看播放夸克网盘资源下载《铁血战士:杀戮之王》–穿越千年的狩猎盛宴，重写人类与异星猎手的宿命对决

时间复杂度：O(1)：插入、删除、查找操作的均摊时间复杂度都是O(1)
空间复杂度：O(n)：栈的存储空间

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