LeetCode（二）：栈与队列

最新推荐文章于 2024-07-28 15:46:11 发布
最新推荐文章于 2024-07-28 15:46:11 发布
阅读量218 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： python 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cyx_1103/article/details/109113606
版权

（四） LeetCode练习题Python3代码

20. 有效的括号

20. 有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1:

输入: "()"
输出: true

示例 2:

输入: "()[]{}"
输出: true

示例 3:

输入: "(]"
输出: false

示例 4:

输入: "([)]"
输出: false

示例 5:

输入: "{[]}"
输出: true

经典的栈的应用，利用栈与字典

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        table = {')': '(', ']':'[', '}':'{'}
        for i in s:
            if i not in table:
                stack.append(i)
            elif not stack or table[i] != stack.pop():
                return False
        return len(stack) == 0
155. 最小栈

155. 最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

  • push(x) —— 将元素 x 推入栈中。
  • pop() —— 删除栈顶的元素。
  • top() —— 获取栈顶元素。
  • getMin() —— 检索栈中的最小元素。

示例:

输入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

输出：
[null,null,null,null,-3,null,0,-2]

解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.

提示：

  • pop、top 和 getMin 操作总是在 非空栈 上调用。
class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []
        self.minStack = []

    def push(self, x: int) -> None:
        self.stack.append(x)
        if not self.minStack:
            self.minStack.append(x)
        elif x <= self.minStack[-1]:
                self.minStack.append(x)

    def pop(self) -> None:
        num = self.stack.pop()
        if num <= self.minStack[-1]:
            self.minStack.pop()

    def top(self) -> int:
        return self.stack[-1]

    def getMin(self) -> int:
        return self.minStack[-1]


# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()
225. 用队列实现栈

225. 用队列实现栈

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

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

注意:

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

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.queue = collections.deque([])

    def push(self, x: int) -> None:
        """
        Push element x onto stack.
        """
        self.queue.append(x)
        self.queue.rotate()

    def pop(self) -> int:
        """
        Removes the element on top of the stack and returns that element.
        """
        return self.queue.popleft()

    def top(self) -> int:
        """
        Get the top element.
        """
        return self.queue[0]

    def empty(self) -> bool:
        """
        Returns whether the stack is empty.
        """
        return not self.queue

# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()
232. 用栈实现队列

232. 用栈实现队列

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

  • 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 操作）。
class MyQueue:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.stack = []

    def push(self, x: int) -> None:
        """
        Push element x to the back of queue.
        """
        self.stack.append(x)

    def pop(self) -> int:
        """
        Removes the element from in front of queue and returns that element.
        """
        return self.stack.pop(0)

    def peek(self) -> int:
        """
        Get the front element.
        """
        return self.stack[0]

    def empty(self) -> bool:
        """
        Returns whether the queue is empty.
        """
        return not self.stack


# 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()
496. 下一个更大元素 I

496. 下一个更大元素 I

给定两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。

示例 1:

输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
    对于num1中的数字4，你无法在第二个数组中找到下一个更大的数字，因此输出 -1。
    对于num1中的数字1，第二个数组中数字1右边的下一个较大数字是 3。
    对于num1中的数字2，第二个数组中没有下一个更大的数字，因此输出 -1。

示例 2:

输入: nums1 = [2,4], nums2 = [1,2,3,4].
输出: [3,-1]
解释:
    对于 num1 中的数字 2 ，第二个数组中的下一个较大数字是 3 。
    对于 num1 中的数字 4 ，第二个数组中没有下一个更大的数字，因此输出 -1 。

提示：

  1. nums1和nums2中所有元素是唯一的。
  2. nums1和nums2 的数组大小都不超过1000。
class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        hashMap = {}
        stack = []
        for num in nums2:
            while stack and stack[-1] < num:
                hashMap[stack.pop()] = num
            
            stack.append(num)

        return [hashMap.get(x, -1) for x in nums1]
682. 棒球比赛

682. 棒球比赛

你现在是棒球比赛记录员。
给定一个字符串列表，每个字符串可以是以下四种类型之一：
1.整数（一轮的得分）：直接表示您在本轮中获得的积分数。
\2. "+"（一轮的得分）：表示本轮获得的得分是前两轮有效 回合得分的总和。
\3. "D"（一轮的得分）：表示本轮获得的得分是前一轮有效 回合得分的两倍。
\4. "C"（一个操作，这不是一个回合的分数）：表示您获得的最后一个有效 回合的分数是无效的，应该被移除。

每一轮的操作都是永久性的，可能会对前一轮和后一轮产生影响。
你需要返回你在所有回合中得分的总和。

示例 1:

输入: ["5","2","C","D","+"]
输出: 30
解释: 
第1轮：你可以得到5分。总和是：5。
第2轮：你可以得到2分。总和是：7。
操作1：第2轮的数据无效。总和是：5。
第3轮：你可以得到10分（第2轮的数据已被删除）。总数是：15。
第4轮：你可以得到5 + 10 = 15分。总数是：30。

示例 2:

输入: ["5","-2","4","C","D","9","+","+"]
输出: 27
解释: 
第1轮：你可以得到5分。总和是：5。
第2轮：你可以得到-2分。总数是：3。
第3轮：你可以得到4分。总和是：7。
操作1：第3轮的数据无效。总数是：3。
第4轮：你可以得到-4分（第三轮的数据已被删除）。总和是：-1。
第5轮：你可以得到9分。总数是：8。
第6轮：你可以得到-4 + 9 = 5分。总数是13。
第7轮：你可以得到9 + 5 = 14分。总数是27。

注意：

  • 输入列表的大小将介于1和1000之间。
  • 列表中的每个整数都将介于-30000和30000之间。
class Solution:
    def calPoints(self, ops: List[str]) -> int:
        stack = []
        for c in ops:
            if c == 'D':
                stack.append(stack[-1] * 2)
            elif c == 'C':
                stack.pop(-1)
            elif c == '+':
                stack.append(stack[-1] + stack[-2])
            else:
                stack.append(int(c))
        return sum(stack)
844. 比较含退格的字符串

844. 比较含退格的字符串

给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。

**注意：**如果对空文本输入退格字符，文本继续为空。

示例 1：

输入：S = "ab#c", T = "ad#c"
输出：true
解释：S 和 T 都会变成 “ac”。

示例 2：

输入：S = "ab##", T = "c#d#"
输出：true
解释：S 和 T 都会变成 “”。

示例 3：

输入：S = "a##c", T = "#a#c"
输出：true
解释：S 和 T 都会变成 “c”。

示例 4：

输入：S = "a#c", T = "b"
输出：false
解释：S 会变成 “c”，但 T 仍然是 “b”。

提示：

  1. 1 <= S.length <= 200
  2. 1 <= T.length <= 200
  3. S 和 T 只含有小写字母以及字符 '#'。

进阶：

  • 你可以用 O(N) 的时间复杂度和 O(1) 的空间复杂度解决该问题吗？
class Solution:
    def backspaceCompare(self, S: str, T: str) -> bool:
        def getString(s):
            stack = []
            for i in s:
                if i == '#' and stack:
                    stack.pop()
                elif i != '#':
                    stack.append(i)
            return ''.join(stack)
        
        return getString(S) == getString(T)

class Solution:
    def backspaceCompare(self, S: str, T: str) -> bool:
        def getString(s):
            skip = 0
            for i in reversed(s):
                if i == '#':
                    skip += 1
                elif skip:
                    skip -= 1
                else:
                    yield i
        return all(x == y for x, y in zip_longest(getString(S), getString(T)))
641. 设计循环双端队列

641. 设计循环双端队列

设计实现双端队列。
你的实现需要支持以下操作：

  • MyCircularDeque(k)：构造函数,双端队列的大小为k。
  • insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true。
  • insertLast()：将一个元素添加到双端队列尾部。如果操作成功返回 true。
  • deleteFront()：从双端队列头部删除一个元素。 如果操作成功返回 true。
  • deleteLast()：从双端队列尾部删除一个元素。如果操作成功返回 true。
  • getFront()：从双端队列头部获得一个元素。如果双端队列为空，返回 -1。
  • getRear()：获得双端队列的最后一个元素。 如果双端队列为空，返回 -1。
  • isEmpty()：检查双端队列是否为空。
  • isFull()：检查双端队列是否满了。

示例：

MyCircularDeque circularDeque = new MycircularDeque(3); // 设置容量大小为3
circularDeque.insertLast(1);			        // 返回 true
circularDeque.insertLast(2);			        // 返回 true
circularDeque.insertFront(3);			        // 返回 true
circularDeque.insertFront(4);			        // 已经满了，返回 false
circularDeque.getRear();  				// 返回 2
circularDeque.isFull();				        // 返回 true
circularDeque.deleteLast();			        // 返回 true
circularDeque.insertFront(4);			        // 返回 true
circularDeque.getFront();				// 返回 4

提示：

  • 所有值的范围为 [1, 1000]
  • 操作次数的范围为 [1, 1000]
  • 请不要使用内置的双端队列库。
class MyCircularDeque:

    def __init__(self, k: int):
        """
        Initialize your data structure here. Set the size of the deque to be k.
        """
        self.length = k
        self.queue = []
        
    def insertFront(self, value: int) -> bool:
        """
        Adds an item at the front of Deque. Return true if the operation is successful.
        """
        if self.isFull():
            return False
        self.queue.insert(0, value)
        return True
        

    def insertLast(self, value: int) -> bool:
        """
        Adds an item at the rear of Deque. Return true if the operation is successful.
        """
        if self.isFull():
            return False
        self.queue.append(value)
        return True

    def deleteFront(self) -> bool:
        """
        Deletes an item from the front of Deque. Return true if the operation is successful.
        """
        if self.isEmpty():
            return False
        self.queue.pop(0)
        return True
        

    def deleteLast(self) -> bool:
        """
        Deletes an item from the rear of Deque. Return true if the operation is successful.
        """
        if self.isEmpty():
            return False
        self.queue.pop(-1)
        return True

    def getFront(self) -> int:
        """
        Get the front item from the deque.
        """
        if self.isEmpty():
            return -1
        return self.queue[0]
        

    def getRear(self) -> int:
        """
        Get the last item from the deque.
        """
        if self.isEmpty():
            return -1
        return self.queue[-1]
        

    def isEmpty(self) -> bool:
        """
        Checks whether the circular deque is empty or not.
        """
        return not self.queue
        

    def isFull(self) -> bool:
        """
        Checks whether the circular deque is full or not.
        """
        return len(self.queue) == self.length
        


# Your MyCircularDeque object will be instantiated and called as such:
# obj = MyCircularDeque(k)
# param_1 = obj.insertFront(value)
# param_2 = obj.insertLast(value)
# param_3 = obj.deleteFront()
# param_4 = obj.deleteLast()
# param_5 = obj.getFront()
# param_6 = obj.getRear()
# param_7 = obj.isEmpty()
# param_8 = obj.isFull()
150. 逆波兰表达式求值

150. 逆波兰表达式求值

根据 逆波兰表示法，求表达式的值。

有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：

  • 整数除法只保留整数部分。
  • 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入: ["2", "1", "+", "3", "*"]
输出: 9
解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：

输入: ["4", "13", "5", "/", "+"]
输出: 6
解释: 该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

示例 3：

输入: ["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"]
输出: 22
解释: 
该算式转化为常见的中缀算术表达式为：
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

  • 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
  • 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

  • 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + *也可以依据次序计算出正确结果。
  • 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中。
class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        stack = []
        character = ['+', '-', '*', '/']
        for c in tokens:
            if c in character:
                num1 = stack.pop()
                num2 = stack.pop()
                if c == character[0]:
                    stack.append(num2 + num1)
                elif c == character[1]:
                    stack.append(num2 - num1)
                elif c == character[2]:
                    stack.append(num2 * num1)
                elif c == character[3]:
                    stack.append(int(num2 / num1))
            else:
                stack.append(int(c))
        return stack[0]
32. 最长有效括号

32. 最长有效括号

给定一个只包含 '(' 和 ')' 的字符串，找出最长的包含有效括号的子串的长度。

示例 1:

输入: "(()"
输出: 2
解释: 最长有效括号子串为 "()"

示例 2:

输入: ")()())"
输出: 4
解释: 最长有效括号子串为 "()()"

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        res = 0
        stack = []
        for i, c in enumerate(s):
            if c == '(' or len(stack) == 0 or s[stack[-1]] == ')':
                stack.append(i)
            else:
                stack.pop()
                res = max(res, i - (stack[-1] if stack else -1))
        return res

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        temp, stack = [], [0] * len(s)
        count, maxCount = 0, 0
        for i,c in enumerate(s):
            if c == '(':
                temp.append(i)
            elif temp:
                stack[temp.pop()], stack[i] = 1, 1
        for num in stack:
            if num:
                count += 1
            else:
                maxCount = max(count, maxCount)
                count = 0
        return max(count, maxCount)
224. 基本计算器

224. 基本计算器

实现一个基本的计算器来计算一个简单的字符串表达式的值。

字符串表达式可以包含左括号 ( ，右括号 )，加号 + ，减号 -，非负整数和空格 。

示例 1:

输入: "1 + 1"
输出: 2

示例 2:

输入: " 2-1 + 2 "
输出: 3

示例 3:

输入: "(1+(4+5+2)-3)+(6+8)"
输出: 23

说明：

  • 你可以假设所给定的表达式都是有效的。
  • 请不要使用内置的库函数 eval。
class Solution:
    def calculate(self, s: str) -> int:
        stack = []
        res, num = 0, 0
        flag = 1
        for c in s:
            if c.isdigit():
                num = num * 10 + int(c)
            elif c == "+":
                res += flag * num
                # 为下一次做准备
                num = 0
                flag = 1
            elif c == "-":
                res += flag * num
                # 为下一次做准备
                num = 0
                flag = -1
            elif c == "(":
                stack.append(res)
                stack.append(flag)
                flag = 1
                res = 0
            elif c == ")":
                res += flag * num
                num = 0
                res = stack.pop() * res + stack.pop()
        res += flag * num
        return res
239. 滑动窗口最大值

239. 滑动窗口最大值

给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回滑动窗口中的最大值。

进阶：

你能在线性时间复杂度内解决此题吗？

示例:

输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7] 
解释: 

  滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

提示：

  • 1 <= nums.length <= 10^5
  • -10^4 <= nums[i] <= 10^4
  • 1 <= k <= nums.length
class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        if len(nums) < 2:
            return nums
        res, queue = [], []
        for i, num in enumerate(nums):
            while queue and nums[queue[-1]] <= num:
                queue.pop()
            queue.append(i)
            if queue[0] <= i - k:
                queue.pop(0)
            if i + 1 >= k:
                res.append(nums[queue[0]])

        return res

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        if len(nums) < 2:
            return nums
        queue = collections.deque()
        res = [0] * (len(nums)-k+1)
        for i in range(len(nums)):
            #保证从大到小 如果前面数小则需要依次弹出，直至满足要求
            while queue and nums[queue[-1]] <= nums[i]:
                queue.pop()
            queue.append(i)
            #判断队首值是否有效
            if queue[0] <= i - k:
                queue.popleft()
            #当窗口长度为k时 保存当前窗口中最大值
            if i + 1 >= k:
                res[i+1-k] = nums[queue[0]] 
        return res
Jaeshn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
排队游戏（栈）
yan_dan的博客
10-10 2203
题目描述 在幼儿园中，老师安排小朋友做一个排队的游戏。首先老师精心的把数目相同的小男孩和小女孩编排在一个队列中，每个小孩按其在队列中的位置发给一个编号（编 号从0开始）。然后老师告诉小朋友们，站在前边的小男孩可以和他后边相邻的小女孩手拉手离开队列，剩余的小朋友重新站拢，再按前后相邻的小男孩小女孩手拉 手离开队列游戏，如此往复。由于教师精心的安排，恰好可以保证每两个小朋友都能手拉手离开队列，并且最...
leetcode232用栈实现队列 空间96%代码+思路
01-20
使用栈实现队列的下列操作： push(x) -- 将一个元素放入队列的尾部。 pop() -- 从队列首部移除元素。 peek() -- 返回队列首部的元素。 empty() -- 返回队列是否为空。 示例: MyQueue queue = new MyQueue(); queue....
数据结构-队列和栈的使用
一串字符串
09-28 174
数据结构-队列和栈的使用 1：问题：一个顺序为1,2,3,4,5,6的栈，依次进入一个队列，然后进栈，顺序是什么？ 答：首先一个顺序为1,2,3,4,5,6的栈，其意思是说进栈的顺序是1,2,3,4,5,6。按照栈的结构，1由于最先进栈，所以被放入栈底；6最后进栈，因此6位于栈顶。 然后进入一个队列。因为只能在栈顶进行出栈操作，也就是说，6最先出栈，1最后出栈。因此队列的入队顺序（也...
排队游戏（括号匹配问题2）
oliver341的专栏
10-19 2005
描述 在幼儿园中，老师安排小朋友做一个排队的游戏。首先老师精心的把数目相同的小男孩和小女孩编排在一个队列中，每个小孩按其在队列中的位置发给一个编号（编 号从0开始）。然后老师告诉小朋友们，站在前边的小男孩可以和他后边相邻的小女孩手拉手离开队列，剩余的小朋友重新站拢，再按前后相邻的小男孩小女孩手拉 手离开队列游戏，如此往复。由于教师精心的安排，恰好可以保证每两个小朋友都能手拉手离开队列，并且最
leetcode刷题：栈与队列02（用队列实现栈）
niTaoTaoa的博客
06-29 1672
力扣题目链接使用队列实现栈的下列操作：注意:
LeetCode:利用栈实现队列
Jiangtagong的博客
01-08 162
尝试使用栈(stack)来实现队列(queue). Example: MyQueue queue=new MyQueue(); queue.push(1); queue.push(2); queue.peek();//returns 1 queue.pop();//returns 1 queue.empty();//return false 解题思路: 可以使用两个栈来实现一个队列:根据队列先进先出的思想,所以必须有一个额外栈翻转一次数组.这个翻转的数组可以在插入时完成, 也可以在取值的时候完成. .
Leetcode：栈和队列
weixin_42390652的博客
01-27 177
文章目录栈剑指offer用两个栈实现队列（剑指offer 09）题目描述分析代码C++版python版包含min函数的栈（剑指offer30）题目描述分析代码C++版python版 栈 剑指offer 用两个栈实现队列（剑指offer 09） 题目描述 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 ) 题目链接 分析 用两个栈组成一个队
LeetCode通关：栈和队列六连，匹配问题有绝招
三分恶的博客
08-20 1628
先进后出是栈，先进先出是队列，来看看栈和队列能解决一些什么问题吧！
LeetCode 232:用栈实现队列
zxjkl123的博客
04-01 130
用栈实现队列 使用栈实现队列的下列操作： push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。 示例: MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.po...
Leetcode 232：用栈实现队列
xiao_xiao_wang_的博客
03-31 132
双栈模拟队列
【Leetcode】用栈实现队列
knous
03-28 1346
如何用栈实现队列，纯C
LeetCode：:laptop:LeetCode解决方案
03-04
7. **数据结构**：栈、队列、链表、树、图、哈希表等。LeetCode的许多问题都是基于这些数据结构设计的，理解它们的性质和操作方法至关重要。 8. **算法**：包括排序（冒泡、选择、插入、快速、归并等）、查找（线性...
leetcode分类-leetcode::waning_crescent_moon:LeetCode算法
06-30
3. **栈（Stack）**：栈是一种后进先出（LIFO）的数据结构，常见问题如括号匹配、最长回文子串等。 4. **队列（Queue）**：队列是先进先出（FIFO）的数据结构，常用于模拟任务调度或广度优先搜索等。 5. **哈希表...
leetcodesolution:leetcodesolution
06-13
1. **基础数据结构**：如数组、链表、栈、队列、堆、哈希表等，这些是解决LeetCode问题的基础工具。 2. **高级数据结构**：如二叉树、图、堆、Trie树、红黑树等，它们在复杂问题中发挥关键作用。 3. **算法**：...
Leetcodejava:Leetcode Java
04-29
- 栈与队列：Java的Stack和Queue接口提供了栈和队列的操作。LeetCode中，它们常用于实现回溯、层序遍历等问题。 - 树：二叉树、平衡树（AVL、红黑树）和 Trie 树等在LeetCode中也占据重要地位，如二叉树的遍历、...
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
qq_64603703的博客
07-27 955
详细解说数据分析pandas库中的常用方法
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 1053
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
全面解析 SnowNLP：中文文本处理、情感分析
有勇气的牛排博客
07-24 718
SnowNLP 是一个专门用于处理中文文本的 Python库。分词情感分析关键词提取文本分类拼音转换繁体转简体词相似度计算等测试环境：Python3.10.9尚未测出该功能text = "有勇气的牛排写的文章通俗易懂，爱了爱了"文本分类使用的是 SnowNLP 的情感分析模型。
Chapter 18 Python异常
最新发布
2302_80253507的博客
07-28 1158
在Python中，异常是一种特定的对象，能够在程序运行过程中被抛出和处理。有效地管理异常不仅可以增强程序的稳定性，还可以提高用户体验，使程序能够优雅地处理错误情况。本章详细讲解了异常的基本概念以及如何捕获和处理异常。
LeetCode题解：编程挑战与解法
2. **数据结构**：文档可能详细解释了在解决问题时使用到的各种数据结构，例如数组、链表、栈、队列、树、图、哈希表等，以及它们在实际问题中的应用。 3. **算法**：涵盖了许多基础和高级算法，如排序（冒泡排序、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值