代码随想录第二十天 | 654 最大二叉树 617 合并二叉树 700 二叉树中的搜索 98 验证二叉搜索树

654 最大二叉树

递归，和昨天那个题思路接近

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if len(nums) == 0:
            return None
        maxNum = max(nums)
        maxNumIndex = nums.index(maxNum)
        node = TreeNode(val = maxNum)
        leftNums = nums[:maxNumIndex]
        rightNums = nums[maxNumIndex+1:]
        node.left = self.constructMaximumBinaryTree(leftNums)
        node.right = self.constructMaximumBinaryTree(rightNums)
        return node

617 合并二叉树

可以用层序遍历合并，再根据合并结果构建二叉树，但是有点麻烦
关键在于，要不断以不为空的二叉树为主树，把另一个加上来，递归访问应该可以
递归情况有点多，写的略繁琐，不过通过了

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        root = self.merge(root1,root2)
        return root

    def merge(self,node1,node2):
        if not node1 and not node2:
            return
        node = TreeNode()
        # 有三种情况，一个空一个有值*2，两个都有值
        if node1 and not node2:
            node.val = node1.val
            if node1.left:
                node.left = self.merge(node1.left,None)
            if node1.right:
                node.right = self.merge(node1.right,None)

        elif not node1 and node2:
            node.val = node2.val
            if node2.left:
                node.left = self.merge(None,node2.left)
            if node2.right:
                node.right = self.merge(None,node2.right)

        elif node1 and node2:
            node.val = node1.val + node2.val
            if node1.left or node2.left:
                node.left = self.merge(node1.left,node2.left)
            if node1.right or node2.right:
                node.right = self.merge(node1.right,node2.right)
                
        return node

解答里面直接返回树要简洁许多

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        root = self.merge(root1,root2)
        return root

    def merge(self,node1,node2):
        if not node1: return node2
        if not node2: return node1

        node1.val += node2.val
        node1.left = self.merge(node1.left,node2.left)
        node1.right = self.merge(node1.right,node2.right)

        return node1

层序遍历也可以，而且不需要先合并再生成树，直接同时遍历两个树即可

700 二叉搜索树中的搜索

前序遍历，递归

class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root: return None
        if root.val == val: return root
        left = self.searchBST(root.left,val)
        right = self.searchBST(root.right,val)
        if left != None:
            return  left
        if right != None:
            return right

这个递归完全是遍历的，没有用到二叉搜索树的性质

class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root: return None
        if root.val == val: return root
        elif root.val > val:
            return self.searchBST(root.left,val)
        elif root.val < val:
            return self.searchBST(root.right,val)

98 验证二叉搜索树

递归检查
重点在于要始终记录根元素值，使得右边子树所有元素都比他大，左边都比他小
逻辑很绕，看解答
中序遍历下，二叉搜索树是有序序列，可根据此性质从中序遍历是否递增来判断
递归中序遍历又忘了

void traversal(TreeNode* cur, vector<int>& vec) {
    if (cur == NULL) return;
    traversal(cur->left, vec);  // 左
    vec.push_back(cur->val);    // 中
    traversal(cur->right, vec); // 右
}

注意，不能只根据是否有序，因为二叉树中可能有重复元素，

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        self.record = []
        self.inOrder(root,self.record)
        for i in range(len(self.record)-1):
            if self.record[i] >= self.record[i+1]:
                return False
        return True
        
    def inOrder(self,node,record):
        if not node: return
        self.inOrder(node.left,record)
        record.append(node.val)
        self.inOrder(node.right,record)