栈和队列练习题

最新推荐文章于 2024-05-12 20:21:26 发布

周闖

最新推荐文章于 2024-05-12 20:21:26 发布

阅读量475

点赞数

分类专栏：算法与数据结构

本文链接：https://blog.csdn.net/Andrew_ZhouC/article/details/105936050

版权

算法与数据结构专栏收录该内容

14 篇文章 0 订阅

订阅专栏

栈和队列的练习题

1. 有效的括号

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

有效字符串需满足：

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

示例 1:

输入: “()”
输出: true

class Solution:
    def isValid(self, s: str) -> bool:
        dic = {'{': '}', '[': ']', '(': ')', '?': '?'}
        stack = ['?']
        for c in s:
            if c in dic:
                stack.append(c)
            elif dic[stack.pop()] != c:
                return False
        return len(stack) == 1

2. 最小栈

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

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

class MinStack:

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

    def push(self, x: int) -> None:
        self.data.append(x)
        if len(self.helper) == 0 or x <= self.helper[-1]:
            self.helper.append(x)
        else:
            self.helper.append(self.helper[-1])

    def pop(self) -> None:
        if self.data:
            self.helper.pop()
            return self.data.pop()

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

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

3. 柱状图中最大的矩形

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

以上是柱状图的示例，其中每个柱子的宽度为 1，给定的高度为 [2,1,5,6,2,3]。

图中阴影部分为所能勾勒出的最大矩形面积，其面积为 10 个单位。

示例:

输入: [2,1,5,6,2,3]
输出: 10

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        # 1. 暴力破解
        res = 0
        n = len(heights)
        for i in range(n):
            left_i = i
            right_i = i
            while left_i >= 0 and heights[left_i] >= heights[i]:
                left_i -= 1
            while right_i < n and heights[right_i] >= heights[i]:
                right_i += 1
            res = max(res, (right_i - left_i - 1) * heights[i])
        return res
        # 2. 单调栈
        stack = []
        heights = [0] + heights + [0]
        res = 0
        for i in range(len(heights)):
            while stack and heights[stack[-1]] > heights[i]:
                tmp = stack.pop()
                res = max(res, (i - stack[-1] - 1) * heights[tmp])
            stack.append(i)
        return res

4. 滑动窗口最大值

给定一个数组 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

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        # 1. 暴力模拟
        res = []
        for i in range(len(nums) - k + 1):
            res.append(max(nums[i:i + k]))
        return res

# 单调栈
class MonotonicQueue:
    def __init__(self):
        self.dq = deque([])

    def push(self, item):
        while self.dq and item > self.dq[-1]:
            self.dq.pop()

        self.dq.append(item)

    def pop(self, item):
        if item == self.dq[0]:
            self.dq.popleft()

    def max(self):
        return self.dq[0]
    

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        if not nums or not k:
            return []

        monotonic_q = MonotonicQueue()

        for i in range(k - 1):
            monotonic_q.push(nums[i])

        result = []

        for i in range(k - 1, len(nums)):
            monotonic_q.push(nums[i])
            result.append(monotonic_q.max())
            monotonic_q.pop(nums[i - k + 1])

        return result

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

class MyCircularDeque(object):

    def __init__(self, k):
        # 长度为k时占用k+1的空间，多出来的空间用来区分isEmpty和isFull
        # 首尾两个指针相等的时候为empty，尾部+1等于首部的时候为Full
        self.q = [0] * (k + 1)
        self.len = k + 1
        self.rear = 0
        self.front = 0

    def move_forward(self, pos):
        return (pos + 1) % self.len

    def move_backward(self, pos):
        return (pos - 1) % self.len

    def insertFront(self, value):
        if not self.isFull():
            # 前端插入始终是先插入后移动，self.front始终指向多出来的那个坑
            self.q[self.front] = value
            self.front = self.move_backward(self.front)
            return True
        else:
            return False

    def insertLast(self, value):
        if not self.isFull():
            # 后端插入始终是先移动后插入，self.rear始终指向后端最后插入的元素
            self.rear = self.move_forward(self.rear)
            self.q[self.rear] = value
            return True
        else:
            return False

    # 删除只需要移动
    def deleteFront(self):
        if not self.isEmpty():
            self.front = self.move_forward(self.front)
            return True
        else:
            return False

    def deleteLast(self):
        if not self.isEmpty():
            self.rear = self.move_backward(self.rear)
            return True
        else:
            return False

    def getFront(self):
        if not self.isEmpty():
            return self.q[self.move_forward(self.front)]
        else:
            return -1

    def getRear(self):
        if not self.isEmpty():
            return self.q[self.rear]
        else:
            return -1

    def isEmpty(self):
        if self.front == self.rear:
            return True
        else:
            return False

    def isFull(self):
        if self.move_forward(self.rear) == self.front:
            return True
        else:
            return False

6. 接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）

示例:

输入: [0,1,0,2,1,0,1,3,2,1,2,1]
输出: 6

class Solution:
    def trap(self, height: List[int]) -> int:
        # 1. 暴力法
        # 能接多少雨水与左右两侧最近的比它高的有关
        if not height:
            return 0
        n = len(height)
        max_left = [0] * n
        max_right = [0] * n
        max_left[0] = height[0]
        max_right[-1] = height[-1]

        for i in range(1, n):
            max_left[i] = max(height[i], max_left[i-1])  # max_left处的值要么为本身，要么为前一个max_left
        for i in range(n - 1 - 1, -1, -1):
            max_right[i] = max(height[i], max_right[i+1])
        res = 0
        for i in range(n):
            res += min(max_left[i], max_right[i])-height[i]
         
        # 2. 双指针
        if not height:
            return 0
        left = 0
        right = len(height) - 1
        res = 0
        # 记录左右两边最大值
        left_max = height[left]
        right_max = height[right]
        while left < right:
            if height[left] < height[right]:
                if left_max > height[left]:
                    res += left_max - height[left]
                else:
                    left_max = height[left]  # 更新 left_max
                left += 1
            else:
                if right_max > height[right]:
                    res += right_max - height[right]
                else:
                    right_max = height[right]  # 更新right_max
                right -= 1
        return res

class Solution:
    def trap(self, height: List[int]) -> int:
        # 单调栈
        length = len(height)
        if length < 3: return 0
        res, idx = 0, 0
        stack = []
        while idx < length:
            while len(stack) > 0 and height[idx] > height[stack[-1]]:
                top = stack.pop()  # index of the last element in the stack
                if len(stack) == 0:
                    break
                h = min(height[stack[-1]], height[idx]) - height[top]
                dist = idx - stack[-1] - 1
                res += (dist * h)
            stack.append(idx)
            idx += 1
        return res

周闖

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
栈和队列练习题

栈和队列的练习题1. 有效的括号给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。有效字符串需满足：看把你们，快慢左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。注意空字符串可被认为是有效字符串。示例 1:输入: “()”输出: trueclass Solution: def isValid(self, s:...
复制链接

扫一扫