力扣刷题笔记 栈与队列及其相关题目

已于 2023-12-16 19:24:07 修改
阅读量86 收藏
点赞数
文章标签： leetcode 笔记 算法
于 2023-12-11 19:52:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sangedianhao/article/details/134756930
版权

 《代码随想录》学习笔记，原链接：https://programmercarl.com/

1.栈与队列基本知识

232.用栈实现队列

225.用队列实现栈

1047.删除字符串中的所有相邻重复项

150.逆波兰表达式求值

239.滑动窗口最大值

347.前K个高频元素

1.栈与队列基本知识

 

232.用栈实现队列

  • 核心代码模式
class MyQueue:

    def __init__(self):
        self.stack_in = []      # 输入栈
        self.stack_out = []     # 输出栈

    def push(self, x: int) -> None:
        self.stack_in.append(x)     # 入栈 

    def pop(self) -> int:
        if self.empty():        # 调用empty()函数，判断对象的输入栈和输出栈是否都为空
            return None

        if self.stack_out:      # 判断输出栈是否为空(不能是self.stack_out.empty())
            return self.stack_out.pop()     # 若不为空，则直接移除stack_out尾部元素，即输出栈的开头元素
        else:
            for i in range(len(self.stack_in)):      # 若输出栈为空，则先将输入栈的数据压倒输出栈，在移除输出栈元素，注意stack_in要加self，而且range(len(self.stack_in))不能改成self.stack_in
                self.stack_out.append(self.stack_in.pop())
            return self.stack_out.pop()      

    def peek(self) -> int:
        result = self.pop()     # 先调用self.pop()函数，将头部元素删除，并提取出来
        self.stack_out.append(result)       # 再将最后一个元素，压回栈

        return result

    def empty(self) -> bool:
        if not (self.stack_in or self.stack_out):        # 判断两个栈是否都为空，注意这里不能是and（逻辑上，应该是stack_in空 和 stack_out空，等价于非（stack_in不空 或 stack_out不空））
            return True

        return False



# 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()
# param_4 = obj.empty()

225.用队列实现栈

  • 核心代码模式 
class MyStack:

    def __init__(self):
        self.queue = deque()     # 构建队列，注意要加self

    def push(self, x: int) -> None:
        self.queue.append(x)     # 将元素放入队列

    def pop(self) -> int:
        if self.empty():        # 判断原队列是否为空
            return None
        
        for i in range(len(self.queue) - 1):        # 弹出最后一个元素，相当于把前面所有元素，出队列后重新压进队列
            self.queue.append(self.queue.popleft())

        return self.queue.popleft()     # 调用列表的popleft()函数，获取队列第一个元素并将其删除

    def top(self) -> int:
        result = self.pop()
        self.queue.append(result)
        return result


    def empty(self) -> bool:
        if not self.queue:      # 如果队列为空，则返回True
            return True
        return False



# 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()

1047.删除字符串中的所有相邻重复项

  • 核心代码模式 
class Solution:
    def removeDuplicates(self, s: str) -> str:
        record = []     # 构建栈

        for i in range(len(s)):
            if len(record) != 0 and s[i] == record[-1]:
                record.pop()        # 若相邻重复则删除
            else:
                record.append(s[i])     # 压入栈
        
        result = "".join(record)        # 将结果拼接成字符串

        return result
  • ACM模式 
class Solution:
    def removeDuplicates(self, s: str) -> str:
        record = []  # 构建栈

        for i in range(len(s)):
            if len(record) != 0 and s[i] == record[-1]:
                record.pop()  # 若相邻重复则删除
            else:
                record.append(s[i])  # 压入栈

        result = "".join(record)  # 将结果拼接成字符串

        return result

# 输入字符串s
s = input("输入字符串s：")

# 删除字符串中的所有相邻重复项
solution = Solution()
result = solution.removeDuplicates(s)
print(result)

150.逆波兰表达式求值

  • 核心代码模式
class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        record = []
        
        for token in tokens:
            if token not in {'+', '-', '*', '/'}:     # 判断当前字符是不是运算符
                record.append(int(token))       # 将数字字符改为int型后压入栈
            else:
                num1 = record.pop()
                num2 = record.pop()
                if token == '+':
                    record.append(num1 + num2)
                if token == '-':
                    record.append(num2 - num1)      # 注意这里根据栈的先进后出，应该是(num2 - num1)  
                if token == '*':
                    record.append(num1 * num2)
                if token == '/':
                    record.append(int(num2 / num1))     # 注意这里根据栈的先进后出，应该是(num2 / num1)，并且向零截断（向零取整）常使用int()来实现

        result = record.pop()       # 将计算结果返回
        return result
  • ACM模式 
class Solution:
    def evalRPN(self, tokens) -> int:
        record = []

        for token in tokens:
            if token not in {'+', '-', '*', '/'}:  # 判断当前字符是不是运算符
                record.append(int(token))  # 将数字字符改为int型后压入栈
            else:
                num1 = record.pop()
                num2 = record.pop()
                if token == '+':
                    record.append(num1 + num2)
                if token == '-':
                    record.append(num2 - num1)  # 注意这里根据栈的先进后出，应该是(num2 - num1)
                if token == '*':
                    record.append(num1 * num2)
                if token == '/':
                    record.append(int(num2 / num1))  # 注意这里根据栈的先进后出，应该是(num2 / num1)，并且向零截断（向零取整）常使用int()来实现

        result = record.pop()  # 将计算结果返回
        return result

# 输入字符串数组tokens
tokens = input("输入字符串数组tokens：").split(",")

# 逆波兰表达式求值
solution = Solution()
result = solution.evalRPN(tokens)
print(result)

239.滑动窗口最大值

  • 核心代码模式
from collections import deque

class Solution:
    def que_pop(self, value):
        if self.queue and self.queue[0] == value:      # 如果单调队列非空，并且要弹出的元素在单调队列队头，则弹出该元素
            self.queue.popleft()

    def que_push(self, value):
        while self.queue and value > self.queue[-1]:       # 如果单调队列非空，而且新加入的元素大于单调队列队尾元素
            self.queue.pop()       # 直接调用pop（）函数，则将小于新加元素的值全部弹出
        self.queue.append(value)      # 直接调用append()函数，将新的元素加入单调队列尾部

    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        self.queue = deque()        # 构建可以被整个类调用的单调队列
        record = []     # 记录最大值

        for i in range(k):      # 先将前k个数字压入队列
            self.que_push(nums[i])
        record.append(self.queue[0])       # 先将前k个元素中的最大值记录下来
        
        for i in range(k, len(nums)):
            self.que_pop(nums[i - k])     # 弹出第i - k个元素
            self.que_push(nums[i])      # 将第i个元素加入单调队列
            record.append(self.queue[0])       # 将此时的最大值保存

        return record
  • ACM模式 
from collections import deque

class Solution:
    def que_pop(self, value):
        if self.queue and self.queue[0] == value:  # 如果单调队列非空，并且要弹出的元素在单调队列队头，则弹出该元素
            self.queue.popleft()

    def que_push(self, value):
        while self.queue and value > self.queue[-1]:  # 如果单调队列非空，而且新加入的元素大于单调队列队尾元素
            self.queue.pop()  # 直接调用pop（）函数，则将小于新加元素的值全部弹出
        self.queue.append(value)  # 直接调用append()函数，将新的元素加入单调队列尾部

    def maxSlidingWindow(self, nums, k):
        self.queue = deque()  # 构建可以被整个类调用的单调队列
        record = []  # 记录最大值

        for i in range(k):  # 先将前k个数字压入队列
            self.que_push(nums[i])
        record.append(self.queue[0])  # 先将前k个元素中的最大值记录下来

        for i in range(k, len(nums)):
            self.que_pop(nums[i - k])  # 弹出第i - k个元素
            self.que_push(nums[i])  # 将第i个元素加入单调队列
            record.append(self.queue[0])  # 将此时的最大值保存

        return record

# 输入整数数组nums和整数k
nums = list(map(int, input("输入字符串数组tokens：").split(",")))
k = int(input("输入整数k："))
print(nums)

# 滑动窗口最大值
solution = Solution()
result = solution.maxSlidingWindow(nums, k)
print(result)

347.前K个高频元素

  •  核心代码模式
import heapq        # 导入小堆栈库

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        record = {}     # 构建哈希表字典，用于统计每个数字出现的频率

        for num in nums:
            record[num] = record.get(num, 0) + 1        # 添加key / 增加已有key的value
        
        prior_queue = []        # 通过列表构建小堆栈，用于统计元素频率

        for key, value in record.items():     # 记录前k个高频元素
            heapq.heappush(prior_queue, (value, key))       # 将(value, key)存入小堆栈，value放在前面有利于排序
            if len(prior_queue) > k:
                heapq.heappop(prior_queue)      # 如果存入的元素大于k个，则将value值最小的那个元素弹出
        
        result = [0] * k        # 构建一个长度为k的列表，存放元素结果
        for i in range(k-1, -1, -1):        # 由于是小堆栈，所以将结果倒叙存入到result中
            result[i] = heapq.heappop(prior_queue)[1]      # 将prior_queue中的最小值依次弹出，并存入result中，注意[1]表示存的是key
        return result

  •  ACM模式
import heapq  # 导入小堆栈库


class Solution:
    def topKFrequent(self, nums, k):
        record = {}  # 构建哈希表字典，用于统计每个数字出现的频率

        for num in nums:
            record[num] = record.get(num, 0) + 1  # 添加key / 增加已有key的value

        prior_queue = []  # 通过列表构建小堆栈，用于统计元素频率

        for key, value in record.items():  # 记录前k个高频元素
            heapq.heappush(prior_queue, (value, key))  # 将(value, key)存入小堆栈，value放在前面有利于排序
            if len(prior_queue) > k:
                heapq.heappop(prior_queue)  # 如果存入的元素大于k个，则将value值最小的那个元素弹出

        result = [0] * k  # 构建一个长度为k的列表，存放元素结果
        for i in range(k - 1, -1, -1):  # 由于是小堆栈，所以将结果倒叙存入到result中
            result[i] = heapq.heappop(prior_queue)[1]  # 将prior_queue中的最小值依次弹出，并存入result中，注意[1]表示存的是key
        return result

# 输入整数数组nums和整数k
nums = list(map(int, input("输入字符串数组tokens：").split(",")))
k = int(input("输入整数k："))
print(nums)

# 前K个高频元素
solution = Solution()
result = solution.topKFrequent(nums, k)
print(result)

通信转爱人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
力扣刷题笔记 栈与队列篇
weixin_45067603的博客
07-29 271
总结先放在前面： 栈和队列是可以互相转换使用的，其中两个栈可以实现一个队列，而一个队列就可以实现栈。栈通常用来解决匹配问题，比如说NO.20. 有效的括号和NO.1047. 删除字符串中的所有相邻重复项 解答栈与队列时的一些小技巧与注意点： 题目实战 1.NO.232.用栈实现队列 public class MyQueue { Stack<int> st1=new Stack<int>(); //st1用来保存数据 Stack<int> st2=new
【力扣刷题笔记】初级算法
qq_42885227的博客
07-22 1712
力扣初级算法刷题笔记
力扣刷题笔记
kuyugoing的博客
05-26 539
力扣刷题笔记：二分法、滑动窗口、链表经典题目。
【力扣刷题学习笔记06（栈与队列）】
SAVSORRY的博客
06-11 1086
输入: ["10", "6", "9", "3", "+", "-11", " * ", "/", " * ", "17", "+", "5", "+"]给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。给定逆波兰表达式总是有效的。给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。给定一个非空的整数数组，返回其中出现频率前 k 高的元素。
力扣刷题笔记 二叉树及其相关题目（含ACM模式）
sangedianhao的博客
01-27 841
递归三部曲核心代码模式result = [] # 记录结果if not root: # 如果当前访问的节点为空，则开始迭代返回return [] # 这里一定是要返回一个空列表，如果什么都不返回，则会在列表拼接时出错# 前序遍历：中，左，右result.append(root.val) # 将中间节点存入到列表中# 这里不要忘记调用函数前要加self.result += self.preorderTraversal(root.left) # 迭代访问左子树，并通过“+”将结果列表拼接。
力扣刷题笔记--设计循环队列（C语言）
m0_63331634的博客
05-16 1205
1.题目要求 题目要求实现指定长度的循环列表，其队尾必须链接在队首之后，且要满足 FIFO（先进先出）原则。 2.基本思路 如果使用单向链表实现这道题，则会出现不好找尾的问题，删除尾之后，前一个指针就成了野指针，而且还会出现无法区分队列满或空的情况，在队列满和空的时候，头指针和尾指针都指向一个位置。 为了方便访问尾的前一个元素，本篇文章采用数组实现循环队列，为了使头和尾指针在列表满与列表空时区分开，在开辟数组时，选择多开一个位置，该位置不存储有效数据。 3.代码实现 typede..
力扣刷题笔记：双端队列与优先队列（滑动串口最大值 & 前K个高频元素）
weixin_44971209的博客
05-06 353
双端队列与优先队列（滑动串口最大值 & 前K个高频元素）知识点一、 滑动窗口最大值二、使用步骤1.引入库2.读入数据总结 知识点 栈与队列基础知识点 栈： 数据先进后出，可以通过stack.push(value)从栈顶添加元素，stack.top()访问栈顶元素，stack.pop()弹出栈顶元素； 队列： 数据先进先出，可以通过queue.push(value)从队尾添加元素，queue.peek()访问队首元素，queue.pop()弹出队首元素； 双端队列： 同时具有栈和队列的性质，可以通过
力扣刷题笔记丨算法数据结构--栈与队列--包含min函数的栈
juehuan1999的博客
02-11 226
1 题目分析 定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。 思路 定义两个栈，一个用来存储数据，另一个用来维护最小值。在存入数据时，比较新数据是否为栈目前的最小值，若是则存入另一个栈。弹出数据时，比较数据是否为栈目前的最小值，若是则也从另一个栈弹出。另一个栈的栈顶始终为最小值。 2 代码实现 定义Minstack类与数据成员stk,stk_min class MinStack { .
力扣刷题笔记 回溯篇
weixin_45067603的博客
08-11 395
总结先放在前面： 解答栈与队列时的一些小技巧与注意点： 题目实战 1.NO.77. 组合 2.NO.77. 组合 3.NO.77. 组合 4.NO.77. 组合 5.NO.77. 组合 6.NO.77. 组合 7.NO.77. 组合 8.NO.77. 组合 9.NO.77. 组合 10.NO.77. 组合
力扣500题刷题笔记10
08-04
力扣题目500题中的第10题主要涉及了...总结来说，力扣500题刷题笔记10主要涉及了图论中的拓扑排序，用于解决课程表问题，判断是否能按照依赖关系完成所有课程的学习。这个问题的关键在于理解和正确实现拓扑排序算法。
力扣刷题精选11111
03-23
《力扣刷题笔记精选》包含了作者在刷题过程中的总结和心得，可能是对特定问题的解题思路，也可能是对某类问题的通用解决方案。这样的笔记可以帮助我们避免重复发明轮子，提升学习效率。同时，通过阅读他人的思考过程...
Leetcode:记录力扣刷题之路
03-15
2. **数据结构**：包括数组、链表、栈、队列、哈希表、树（如二叉树、平衡树AVL和红黑树）、图等。理解这些数据结构的特性和操作，能够有效地解决问题。 3. **算法**：排序算法（如冒泡排序、快速排序、归并排序、...
labuladong的刷题笔记V2.0(力扣版)
03-17
《labuladong的刷题笔记V2.0(力扣版)》是一份详尽的编程学习资源，主要针对LeetCode这个在线编程挑战平台。LeetCode是许多程序员提升技能、准备面试的重要工具，它提供了丰富的算法题目，涵盖数据结构、排序、搜索、...
labuladong的算法秘籍+刷题笔记V2.0
09-17
这套资料包含两部分：《labuladong的刷题笔记V2.0(力扣版).pdf》和《labuladong的算法秘籍V2.0(力扣版).pdf》。这两份文档旨在帮助读者深入理解和掌握在LeetCode等在线编程挑战平台上的核心算法与问题解决技巧。 ...
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 126
C语言 | Leetcode C语言题解之第337题打家劫舍III
【长度最小的子数组】python刷题记录
m0_73629042的博客
08-12 207
【代码】【长度最小的子数组】python刷题记录。
Java | Leetcode Java题解之第337题打家劫舍III
m0_57195758的博客
08-15 221
Java | Leetcode Java题解之第337题打家劫舍III
【LeetCode每日一题】——623.在二叉树中增加一行
IronmanJay的博客
08-14 822
给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 注意，根节点 root 位于深度 1 。 加法规则如下: 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 cur 原来的左子树应该是新的左子树根的左子树。 cur 原来的右子树应该是新的右子树根的右子树。 如果 depth == 1 意味着 depth - 1 根本没有深度
力扣刷题笔记.pdf
12-11
力扣刷题笔记.pdf是一份非常重要的学习资料，里面记录了刷力扣题目时的一些关键思路、解题方法和总结。在这份笔记中，可以记录下每道题的解法和思路，以及一些常见的错误和易错点。这样在以后复习和总结的时候，就...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值