代码随想录算法训练营第二十天| LeetCode654.最大二叉树、LeetCode617.合并二叉树、LeetCode700.二叉搜索树中的搜索、LeetCode98.验证二叉搜索树

654.最大二叉树

题目描述: 654.最大二叉树.

解法

递归

class Solution(object):
    def constructMaximumBinaryTree(self, nums):
        if not nums:
            return None
        max_val = max(nums)
        max_index = nums.index(max_val)
        root = TreeNode(max_val)
        root.left = self.constructMaximumBinaryTree(nums[:max_index])
        root.right = self.constructMaximumBinaryTree(nums[max_index+1:])
        return root

617.合并二叉树

题目描述: 617.合并二叉树.

解法

递归

class Solution(object):
    def mergeTrees(self, root1, root2):
        if not root1:
            return root2
        if not root2:
            return root1
        root1.val += root2.val
        root1.left = self.mergeTrees(root1.left,root2.left)
        root1.right = self.mergeTrees(root1.right,root2.right)
        return root1

迭代

class Solution(object):
    def mergeTrees(self, root1, root2):
        if not root1:
            return root2
        if not root2:
            return root1
        que = collections.deque([root1,root2])
        
        while que:
            node1 = que.popleft()
            node2 = que.popleft()

            if node1.left and node2.left:
                que.append(node1.left)
                que.append(node2.left)
            if node1.right and node2.right:
                que.append(node1.right)
                que.append(node2.right)
            
            node1.val += node2.val
            if not node1.left and node2.left:
                node1.left = node2.left
            if not node1.right and node2.right:
                node1.right = node2.right
        return root1

迭代和递归地主要思路是相似的，由于两个树是不一样的，所以不可能将两个树的所有节点都遍历到。如果两个树都有的节点，要进行相加的处理，如果只有一个树有节点，那么就直接把这个节点搬过来就行，如果两个数都没有这个节点，跳过即可。

700.二叉搜索树中的搜索

题目描述: 700.二叉搜索树中的搜索.

解法

递归

class Solution(object):
    def searchBST(self, root, val):
        if not root or root.val == val:
            return root
        if root.val > val:
            return self.searchBST(root.left,val)
        else:
            return self.searchBST(root.right,val)
        """

迭代

class Solution(object):
    def searchBST(self, root, val):
        if not root or root.val == val:
            return root

        que = deque([root])
        while que:
            node = que.popleft()
            if not node or node.val == val:
                return node
            if node.val > val:
                que.append(node.left)
            else:
                que.append(node.right)

98.验证二叉搜索树

题目描述: 98.验证二叉搜索树.

解法

递归

class Solution(object):
    def travel(self,root):
        if not root:
            return []
        left = self.travel(root.left)
        right = self.travel(root.right)
        return left + [root.val] + right

    def isValidBST(self, root):
        if not root:
            return True
        nums = self.travel(root)
        for i in range(len(nums)-1):
            if nums[i] >= nums[i+1]:
                return False
        return True

设值

class Solution(object):
    def __init__(self):
        self.min_val = float('-inf')

    def isValidBST(self, root):
        if not root:
            return True
        left = self.isValidBST(root.left)
        if self.min_val < root.val:
            self.min_val = root.val
        else:
            return False
        right = self.isValidBST(root.right)
        return left and right

设指针

class Solution(object):
    def __init__(self):
        self.pre= None

    def isValidBST(self, root):
        if not root:
            return True
        left = self.isValidBST(root.left)

        if not self.pre or root.val > self.pre.val:
            self.pre = root
        else:
            return False
    
        right = self.isValidBST(root.right)
        return left and right

迭代

class Solution(object):
    def isValidBST(self, root):
        if not root:
            return True
        st = [root]
        pre = None
        while st:
            node = st.pop()
            if node:
                if node.right:
                    st.append(node.right)
                st.append(node)
                st.append(None)
                if node.left:
                    st.append(node.left)

            else:
                node = st.pop()
                if not pre or pre.val < node.val:
                    pre = node
                else:
                    return False
        return True