day17 第六章 二叉树 part05

654.最大二叉树

构造二叉树都是 前序遍历

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if not nums:
            return None
        return self.traversal(nums, 0, len(nums))

    def traversal(self, nums: List[int], start: int, end: int) -> Optional[TreeNode]:
        # [)
        if start == end:
            return None
        
        max_value = 0
        max_index = start
        for i in range(start, end):
            if nums[i] > max_value:
                max_value = nums[i]
                max_index = i

        root = TreeNode(val = max_value)

        if end-start == 1:
            return root

        # split nums
        left_nums_start = start
        left_nums_end = max_index
        right_nums_start = max_index + 1
        right_nums_end = end

        root.left = self.traversal(nums, left_nums_start, left_nums_end)
        root.right = self.traversal(nums, right_nums_start, right_nums_end)
        return root

617.合并二叉树

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root1 and not root2:
            return None

        node = TreeNode()
        if not root1 and root2:
            node.val = root2.val
            node.left = self.mergeTrees(None, root2.left)
            node.right = self.mergeTrees(None, root2.right)
        elif root1 and not root2:
            node.val = root1.val
            node.left = self.mergeTrees(root1.left, None)
            node.right = self.mergeTrees(root1.right, None)
        else:
            node.val = root1.val + root2.val
            node.left = self.mergeTrees(root1.left, root2.left)
            node.right = self.mergeTrees(root1.right, root2.right)
            
        return node

简洁版

如果t1为空，合并之后就是t2

如果t2为空，合并之后就是t1

直接return 不需要继续

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2
        if (t2 == NULL) return t1; // 如果t2为空，合并之后就应该是t1
        // 修改了t1的数值和结构
        t1->val += t2->val;                             // 中
        t1->left = mergeTrees(t1->left, t2->left);      // 左
        t1->right = mergeTrees(t1->right, t2->right);   // 右
        return t1;
    }
};

层序

层序：破坏了树状结构，很难重新构造，一般不用于构造树

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        # 层序法: 破坏了树状结构，很难重新构造，还是得用r1或r2已有的结构
        if not root1:
            return root2
        if not root2:
            return root1
        
        q = collections.deque()
        q.append(root1)
        q.append(root2)
        # node = TreeNode()
        while q:
            node1 = q.popleft()
            node2 = q.popleft()
            node1.val += node2.val
            if node1.left and node2.left:
                q.append(node1.left)
                q.append(node2.left)
            if node1.right and node2.right:
                q.append(node1.right)
                q.append(node2.right)
            if not node1.left and node2.left:
                node1.left = node2.left
            if not node1.right and node2.right:
                node1.right = node2.right
            # if node1.left and not node2.left:
            #     node.left = node1.left
            # if node1.right and not node2.right:
            #     node.right = node1.right

        return root1

700.二叉搜索树中的搜索

递归

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        # 递归
        if not root or root.val == val:
            return root
        if val < root.val:
            return self.searchBST(root.left, val)
        if val > root.val:
            return self.searchBST(root.right, val)

迭代

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        # 迭代
        while root:
            if val < root.val:
                root = root.left
            elif val > root.val:
                root = root.right
            else:
                return root

        return None

98.验证二叉搜索树

二叉搜索树：中序

Pre or max_value should be reset every instance, so it can't be a class variable.

Even if it has to be a class variable, it should be reset every time the instance calls.

class Solution:
    def __init__(self):
        self.pre = None  # 用来记录前一个节点

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

        if self.pre and self.pre.val >= root.val:
            return False
        self.pre = root  # 记录前一个节点

        right = self.isValidBST(root.right)
        return left and right

class Solution:
    def __init__(self):
        self.max_value = float('-inf')  # 用来记录前一个节点

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

        if self.max_value >= root.val:
            return False
        self.max_value = root.val  # 记录前一个节点

        right = self.isValidBST(root.right)
        return left and right