剑指offer【模拟】

顺时针打印指针

image.png

依次为：从左到右，从上到下，左右到左，从下到上；
修改边界，继续，直到完成
注意每次更新边界之后需要确认是否越界；越界即跳出

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        # 特殊case
        if not matrix:
            return []
        # 定义上下左右边界
        l, r, t, b = 0, len(matrix[0])-1, 0, len(matrix)-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

栈的压入、弹出

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。

例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

• 由于不知道1，2，3，4，5从什么时候开始往外pop，所以，栈顶元素 = 弹出序列的当前元素时，意味着进行了出栈操作。
• 建立一个辅助栈，模拟序列的操作
• 循环push进nums，
• 用一个指针，来遍历弹出序列；
• 如果当前指针指向的弹出元素 = 栈顶的元素， 直接出栈 (这里需要循环)；
• 然后再继续push进去
• 这样，如果最终辅助栈空了，就是完全和弹出序列吻合，可以实现；

class Solution:
    def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
        # 用于遍历弹出序列的指针
        j = 0
        stack = []
        for num in pushed:
             stack.append(num)
             # 判断是否进行了pop操作
             # 循环判断与出栈
             while stack and popped[j] == stack[-1]:
                 stack.pop()
                 j += 1
        return not stack