Day 18 二叉树 part06

先补昨天的两题：

LC 617. 合并二叉树

这道题关键要理解，是两棵树同时在遍历，可以想象先把两棵树重叠在一起。当root1为空时，root2节点就是新节点，root2为空时，root1节点就是新节点，此即递归出口（两者同时为空的情况包含在上面了）。当两者不同时为空，需要向下继续遍历，即单层处理逻辑。

我们直接在root1这棵树上操作，无需创建一颗新的树

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if root1 == None : return root2
        if root2 == None : return root1

        root1.val += root2.val
        root1.left = self.mergeTrees(root1.left , root2.left)
        root1.right = self.mergeTrees(root1.right , root2.right)

        return root1

LC 98. 验证二叉搜索树

最容易想的办法是先中序遍历，拿到遍历的结果数组，直接比较数组是否单调递增。然后成功击败5%~

class Solution:
    def inorder(self , root):
        if root == None:
            return 
        self.inorder(root.left)
        self.res.append(root.val)
        self.inorder(root.right)
        return self.res

    def func(self,ls):
        for i in range(0 , len(ls) - 1):
            if ls[i] >= ls[i+1]:
                return False
        return True


    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        self.res = []
        return self.func(self.inorder(root))

递归的方法是，中序遍历，用一个Max记录左右子树的最大值，再和根节点比较

class Solution:
    def __init__(self):
        self.Max = -float('inf')
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        left = self.isValidBST(root.left)
        if self.Max < root.val:
            self.Max = root.val
        else:
            return False
        right = self.isValidBST(root.right)
        return left and right

LC 530 二叉搜索树的最小绝对差

直观想法：中序遍历转换成数组，再计算最小值

class Solution:
    def inorder(self , node , res):
        if not node:
            return None
        self.inorder(node.left , res)
        res.append(node.val)
        self.inorder(node.right , res)
        return res
    def examine(self,res):
        ans = float('inf')
        for i in range(len(res)-1):
            ans = min(ans , res[i+1] - res[i])
        return ans
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        res = []
        return self.examine(self.inorder(root , res))

法二：

双指针，pre指向node的上一个节点，随着node遍历过程中，不断赋值pre = node，使pre跟着node遍历。然后设置一个全局变量res（因为要不断地改变res，所以res必须设置在遍历函数外面的，这样才能被不断修改），记录最小的差值

class Solution:
    def __init__(self):
        self.result = float('inf')
        self.pre = None
    def traversal(self, cur):
        if cur is None:
            return
        self.traversal(cur.left)  
        if self.pre is not None:  
            self.result = min(self.result, cur.val - self.pre.val)
        self.pre = cur  
        self.traversal(cur.right)  

    def getMinimumDifference(self, root):
        self.traversal(root)
        return self.result