Python剑指offer系列_3

18 顺时针打印矩阵

18.1 题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.

18.2 解题思路

本题可以先打印出矩阵的第一行，然后逆时针旋转，再打印第一行，直至矩阵为空时，停止打印。代码如下：

class Solution:
    # matrix类型为二维列表，需要返回列表
    def printMatrix(self, matrix):
        if not matrix:
            return None
        result = []
        while matrix:
            result.extend(matrix[0])
            matrix = self.reverseMatrix(matrix[1:])
        return result

    def reverseMatrix(self, matrix):
        if not matrix:
            return None
        m = len(matrix)
        n = len(matrix[0])
        new_matrax = []
        for i in range(n-1, -1, -1):
            matrix_1 = []
            for j in range(m):
                matrix_1.append(matrix[j][i])
            new_matrax.append(matrix_1)
        return new_matrax

19 包含min函数的栈

19.1 题目描述

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

19.2 解题思路

本题中要实现栈的元素添加、弹出、取最小值。栈的元素添加、弹出相对简单。遵循栈的“先进后出”原则，只需调用列表的append、pop方法即可。要想实现时间复杂度为O(1)的min方法，可以设置辅助栈，每次判断加入的值是不是最小，若最小，添加到辅助栈中。如果弹出的是栈中的最小值，就把辅助栈中的最小值也删掉。代码如下：

class Solution:
    def __init__(self):
        self.stack = []
        self.min_stack = []

    def push(self, node):
        if not self.min_stack:
            self.min_stack.append(node)
        if self.min_stack[-1] > node:
            self.min_stack.append(node)
        return self.stack.append(node)

    def pop(self):
        if self.min_stack[-1] == self.stack[-1]:
            self.min_stack.pop()
        return self.stack.pop()

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

    def min(self):
        return self.min_stack[-1]

20 栈的压入、弹出序列

20.1 题目描述

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

20.2 解题思路

本题的大概思路为设置一个辅助栈stack，将pushV里的数字压入stack，如果压入的数字与popV里的一样，那么就将pushV和popV里的这个数字删除，并检查popV的前一个数字是否为stack中的压入数字，是就删除。直到pushV里的数字全部压入辅助栈中。这时再检查辅助栈剩下的数字与popV中是否一样，一样就返回True。代码如下：

class Solution:
    def __init__(self):
        self.stack = []

    def IsPopOrder(self, pushV, popV):
        pushV = list(reversed(pushV))
        popV = list(reversed(popV))
        while pushV:
            if pushV[-1] != popV[-1]:
                self.stack.append(pushV.pop())
            else:
                pushV.pop()
                popV.pop()
                if pushV:
                    while self.stack[-1] == popV[-1]:
                        self.stack.pop()
                        popV.pop()

        if self.stack == popV:
            return True
        return False

后来觉得自己的思路实现过程有点繁琐，又参考了其他的实现方法。其大致思路差不多。只是在判断辅助栈与popV里的数字时，这里是将其一直删除，若最后辅助栈里没有数字，则说明删完了，返回True，否则返回False。代码如下：

class Solution:
    def __init__(self):
        self.stack = []

    def IsPopOrder(self, pushV, popV):

        for i in pushV:
            self.stack.append(i)
            while len(self.stack) and self.stack[-1] == popV[0]:
                self.stack.pop()
                popV.pop(0)

        if len(self.stack):
            return False
        return True

21 从上往下打印二叉树

21.1 题目描述

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

21.2 解题思路

本题要求从上到下、从左到右的打印二叉树节点，一层一层的遍历二叉树，可设一个辅助列表，借助队列的性质完成。当节点的左右子树不为空时，就将节点添加到辅助列表中，队列遵循“先进先出”的原则，在一端加入节点，另一端输出节点。当辅助列表长度为0时，就说明已经完成遍历。需要注意的是，在这里当二叉树为空时，输出的是[]，而不是None。代码如下：

class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        result = []
        sequence = []
        if root is None:
            return []
        sequence.append(root)
        while len(sequence) > 0:
            node = sequence.pop()
            result.append(node.val)
            if node.left is not None:
                sequence.insert(0, node.left)
            if node.right is not None:
                sequence.insert(0, node.right)
        return result

22 二叉搜索树的后序遍历序列

22.1 题目描述

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

22.2 解题思路

首先要弄清楚二叉搜索树概念。在二叉搜索树中树的根节点总是大于左右子树节点的值。在后序遍历中，根节点总是在序列的最后，因此可按大小值区分左右子树。分开后，若右子树中含有比根节点大的节点，则说明该数组不是二叉搜索树的后序遍历。需要注意的是边界条件。若分开后的左子树为空，则继续遍历右子树；若右子树为空，则返回True，否则递归判断左右子树。代码如下：

class Solution:
    def __init__(self):
        self.index = 0

    def VerifySquenceOfBST(self, sequence):
        if not sequence:
            return False
        if len(sequence) == 1:
            return True
        node = sequence[-1]
        for i in range(len(sequence)):
            if sequence[i] > node:
                self.index = i
                break
            if i == len(sequence) - 1:
                self.index = i
        left = sequence[:self.index]
        right = sequence[self.index:-1]
        if not right:
            return True
        else:
            for i in range(len(right)):
                if right[i] < node:
                    return False

        if left:
            return self.VerifySquenceOfBST(left) and self.VerifySquenceOfBST(right)
        else:
            return self.VerifySquenceOfBST(right)

自我感觉自己写的复杂，又参考其他答案，觉得有一种思路不错。代码如下：

class Solution:
    def __init__(self):
        self.index = 0

    def VerifySquenceOfBST(self, sequence):
        if not sequence:
            return False
        return self.Right_Left(sequence)

    def Right_Left(self, sequence):
        if not sequence:
            return True
        node = sequence[-1]
        for i in range(len(sequence)):
            if sequence[i] > node:
                self.index = i
                break
            if i == len(sequence) - 1:
                self.index = i
        left = sequence[:self.index]
        right = sequence[self.index:-1]
        if right:
            for i in range(len(right)):
                if right[i] < node:
                    return False
        return self.Right_Left(left) and self.Right_Left(right)

这种解法设了一个判断左右子树的函数，当传入的函数为空时，返回True，省去了那么多的判断。