刷题记录-day12 （按之字形顺序打印二叉树、二叉搜索树的第k个节点、重建二叉树、树的子结构）

1.按之字形顺序打印二叉树

class Solution:
    def Print(self , pRoot: TreeNode) -> List[List[int]]:
        # write code here
        # 套用了遍历二叉树的模板，这个模板很重要必须记住
            # 构建两个数组，一个作为最终返回，一个作为先入先出的队列
            # 将队列初始化为根节点，然后每当队列中第一个加入最终返回时，都将这个加入的值的左右子节点加到队列末尾
            # 这样保证了不像递归一样把右子节点的位置挤掉，而是排到后面
        # 然后遍历每一层，奇数时反转
        if not pRoot:
            return []
        nodestack = [pRoot]
        result = []
        while nodestack:
            res = []
            nextstack = []
            for i in nodestack:
                res.append(i.val)
                if i.left:
                    nextstack.append(i.left)
                if i.right:
                    nextstack.append(i.right)
            nodestack = nextstack
            result.append(res)
        returnRes = []
        for idx,v in enumerate(result):
            if idx%2==0:
                returnRes.append(v)
            else:
                returnRes.append(v[::-1])
        return returnRes

2.二叉搜索树的第k个节点

class Solution:
    def KthNode(self , proot: TreeNode, k: int) -> int:
        # write code here
        # 还是运用了遍历二叉树的模板，遍历完成后直接排序，然后取第k个就可以
        if not proot:
            return -1
        numbers = []
        stack = [proot]
        while stack:
            temp = stack[0]
            numbers.append(temp.val)
            stack = stack[1:]
            if temp.left:
                stack.append(temp.left)
            if temp.right:
                stack.append(temp.right)
        numbers = sorted(numbers)
        if k > len(numbers) or k < 1:
            return -1
        return numbers[k-1]

3.重建二叉树

class Solution:
    def reConstructBinaryTree(self , pre: List[int], vin: List[int]) -> TreeNode:
        # write code here
        # 需要熟练得掌握前序遍历（根左右）和中序遍历（左根右）
        # 例如前序为[1,2,3,4,5,6,7], 中序为[3,2,4,1,6,5,7]
        # 前序的第一个元素（1）一定为根，中序中（1）的前面元素（3,2,4）为根的左子树，后面元素（6,5,7）为根的右子树
        # 使用递归的方法依次构建左右子树，左子树的前序为（2,3,4），中序为（3,2,4）
        # 右子树的前序为（5,6,7），中序为（6,5,7）
        if not pre:
            return None
        root = TreeNode(pre[0])
        tmp = vin.index(pre[0])
        root.left = self.reConstructBinaryTree(pre[1:tmp+1],vin[:tmp])
        root.right = self.reConstructBinaryTree(pre[tmp+1:], vin[tmp+1:])
        return root

4. 树的子结构

class Solution:
    def HasSubtree(self , pRoot1: TreeNode, pRoot2: TreeNode) -> bool:
        # write code here
        # 还是使用递归的思路
        # 明确，root1有的，root2可以没有，root1没有的，root2一定不能有，否则root1无法包含root2
        # 自定义比较函数，判断当前树根是否对应子结构（root2为null时也是对应的）
        if not pRoot1 or not pRoot2:
            return False
        def bijiao(A,B):
            if not B:
                return True
            elif not A:
                return False
            elif A.val != B.val:
                return False
            return bijiao(A.left,B.left) and bijiao(A.right,B.right)
        return bijiao(pRoot1,pRoot2) or self.HasSubtree(pRoot1.left,pRoot2) or self.HasSubtree(pRoot1.right,pRoot2)