剑指offer刷题记录｜顺序刷题第四周

剑指offer 32-III 从上到下打印二叉树

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res = []
        queue = collections.deque()
        queue.append(root)
        i=0
        while queue:
            tmp = []
            for _ in range(len(queue)):
                node = queue.popleft()
                tmp.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            if i%2==0: 
                res.append(tmp)
                i+= 1
            else: 
                res.append(tmp[::-1])
                i+=1
        return res

剑指offer 32-II 从上到下打印二叉树

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        # 特殊情况，root为空
        if not root: return []
        res = []
        # 节点序列collections.deque 入栈append 弹出popleft
        queue = collections.deque()
        queue.append(root)
        while queue:
            tmp = []
            for _ in range(len(queue)):
                node = queue.popleft()
                tmp.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            res.append(tmp)
        return res

剑指offer 32-I 从上到下打印二叉树

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        if not root: return []
        res = []
        # 要建立一个结点序列，保存左右结点，这样才可以每层从左到右。如果是直接递归，是深度优先输出。
        queue = collections.deque()
        queue.append(root)
        while queue:
            node = queue.popleft()
            res.append(node.val)
            if node.left: queue.append(node.left)
            if node.right: queue.append(node.right)
        return res

剑指offer 31 栈的压入、弹出序列

class Solution:
    def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
        res = []
        i = 0
        for ele in pushed:
            res.append(ele)
            while res and res[-1] == popped[i]:
                res.pop()
                i+=1
        return not res

剑指offer 30 包含min函数的栈

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] if self.A else None

    def min(self) -> int:
        # 直接用了min函数，不好！应该自己写一个辅助栈，保存最小值。所以有两个list，第二个用于保存min。
        return self.B[-1]

剑指offer 29 顺时针打印矩阵

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        # python可以将第一行加入res，剩下的旋转，再选取第一行加入res，如此。
        res = []
        while matrix:
            res += matrix.pop(0)
            matrix = list(zip(*matrix))[::-1] # list(zip(*matric))是矩阵每列为一个元素
        return res

剑指offer 25 合并两个序列的链表

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        # 用0新建一个链表，用cur移动构建链表，返回res.next得到完整链表
        # 思路：不断将小的结点进行拼接，直至一个为null，将另一个拼接在后面
        res = cur = ListNode(0)
        while l1 and l2:
            if l1.val  >= l2.val:
                cur.next = l2
                l2 = l2.next
            else:
                cur.next = l1
                l1 = l1.next
            cur = cur.next
        cur.next = l1 if l1 else l2
        return res.next