剑指offer-Python3版(七)

剑指offer-Python3版(七)

顺时针打印矩阵

Q: 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

思路

不是很复杂，就按照题目给的思路。

   [[1,2,3],
    [4,5,6],
    [7,8,9],]
# 从边界遍历读取 

class Solution:
    def spiralOrder(self, matrix: [[int]]) -> [int]:
        # 空矩阵 返回空
        if not matrix:
            return []
        # 上下左右 默认值为 t d l r
        t, b, l, r = 0, len(matrix) - 1, 0, len(matrix[0]) - 1
        # 返回值
        res = []
        while True:
            # 从左到右
            for i in range(l, r + 1):
                res.append(matrix[t][i])
            t += 1
            if t > b:
                break
            # 从上到下
            for i in range(t, b + 1):
                res.append(matrix[i][r])
            r -= 1
            if l > r:
                break
            # 从右到左
            for i in range(r, l - 1, -1):
                res.append(matrix[b][i])
            b -= 1
            if t > b:
                break
            # 从下到上
            for i in range(b, t - 1, -1):
                res.append(matrix[i][l])
            l += 1
            if l > r:
                break
        return res

包含min函数的栈

Q: 定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

思路

就是限制在了O(1),怎么写时间复杂度才能在O(1)呢？

通过建立辅助栈可以实现

数据栈A  用来保证push pop等功能
辅助栈B  用来存储A中保持非严格降序的元素，取B的栈顶就是最小值

class MinStack:

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

    def push(self, x: int) -> None:
        self.A.append(x)
        if not self.B or self.B[-1] >= x:
            self.B.append(x)

    def pop(self) -> None:
        if self.A.pop() == self.B[-1]:
            self.B.pop()

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

    def min(self) -> int:
        return self.B[-1
    

栈的压入、弹出序列

Q:输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

思路

利用辅助栈，模拟压入弹出操作，判断是否模拟成功。

class Solution:
    def validateStackSequences(self, pushed: [int], popped: [int]) -> bool:
        # 初始化模拟栈
        stack, i = [], 0
        for num in pushed:
            # 持续压入辅助栈，直到辅助栈的栈顶=弹出栈的第i个元素 弹出，再i+1
            # stack空了，说明是成功的
            stack.append(num)
            while stack and stack[-1] == popped[i]:
                stack.pop()
                i += 1
        return not stack