代码随想录算法训练营第十七天 | 654.最大二叉树 617.合并二叉树 700.二叉搜索树中是搜索 98.验证二叉搜索树

LeetCode 654.最大二叉树：

文章链接
题目链接: 654.最大二叉树

思路：

与之前根据前序/后序与中序构造二叉树的思路相似：

1. 重新构造列表

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if nums == []:
            return None
        root = self.traversal(nums)
        return root
    
    def findMax(self, nums):
        if nums == []:
            return -1, -1
        maxIndex = 0
        for i in range(1, len(nums)):
            if nums[i] > nums[maxIndex]:
                maxIndex = i
        return maxIndex, nums[maxIndex]
    def traversal(self, nums):
        if nums == []:
            return None
        #rootIndex, rootValue = self.findMax(nums)
        rootIndex = nums.index(max(nums))
        root = TreeNode(val=nums[rootIndex])

        # 切分
        leftNums = nums[:rootIndex]
        rightNums = nums[rootIndex + 1:]

        # 构造
        root.left = self.traversal(leftNums)
        root.right = self.traversal(rightNums)
        return root

2. 使用索引

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        root = self.traversal(nums, 0, len(nums) - 1)
        return root

    def traversal(self, nums, left, right): # 双闭区间
        if left > right:
            return None
        # maxIndex = nums.index(max(nums[left:right + 1]))
        maxIndex = left
        for i in range(left + 1, right + 1):
            if nums[i] > nums[maxIndex]:
                maxIndex = i
        root = TreeNode(val=nums[maxIndex])
        root.left = self.traversal(nums, left, maxIndex - 1)
        root.right = self.traversal(nums, maxIndex + 1, right)
        return root

---

LeetCode 617.合并二叉树：

文章链接
题目链接：617.合并二叉树

思路：

1. 递归：
   ① 参数和返回值：传入两棵二叉树的节点，返回合并后的节点
   ② 边界条件：有一个节点为None，返回另一个节点
   ③ 正常递归条件：要么构造新节点，要么以某一棵树为新二叉树。下面以root1为新二叉树，将节点值相加，递归构造左子树和右子树

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        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

2. 迭代
   使用队列来进行迭代（与对称二叉树的思路相似），也是单独判断两个节点的左右孩子是否存在然后判断是否入队和处理

from collections import deque
class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root1:   return root2
        if not root2:   return root1
        queue = deque()
        queue.append(root1)
        queue.append(root2)
        while queue:
            t1 = queue.popleft()
            t2 = queue.popleft()
            t1.val += t2.val
            if t1.left and t2.left: # 两个节点的左孩子都存在，入队
                queue.append(t1.left)
                queue.append(t2.left)
            elif not t1.left and t2.left:   # 以root1为新二叉树，若t1.left不存在，将t2左孩子赋给t1.left
                t1.left = t2.left
        
            if t1.right and t2.right:   # 两个节点的右孩子都存在
                queue.append(t1.right)
                queue.append(t2.right)
            elif not t1.right and t2.right: # 将t2右孩子赋给t1的右孩子
                t1.right = t2.right
        return root1

---

LeetCode 700.二叉搜索树中的搜索：

文章链接
题目链接：700.二叉搜索树中的搜索

思路：

二叉搜索树的特性是：如果左子树存在，那么左子树上所有节点的值 < 根节点的值；如果右子树存在， 那么右子树上所有节点的值 > 根节点的值。且左右子树也是二叉搜索树

1. 根据二叉搜索树的特性：
   可以不利用栈/队列来访问二叉搜索树，因为二叉搜索树BST是有序的，搜索下去不用回溯，因此不需要用栈/队列保存之前的分支

#迭代
class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        node = root
        while node:
            if node.val == val:
                return node
            elif node.val > val:
                node = node.left
            else:
                node = node.right
        return node

# 递归
class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        self.val = val
        return self.traversal(root)

    def traversal(self, node):
        if not node:
            return None
        if node.val == self.val:
            return node
        elif node.val > self.val:   # 在左子树
            left_node = self.traversal(node.left)
            return left_node
        else:   # 在右子树
            right_node = self.traversal(node.right)
            return right_node

2. 一般二叉树的解法
   此处以层序遍历为例

from collections import deque
class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        queue = deque()
        if root: queue.append(root)
        while queue:
            q_size = len(queue)
            for _ in range(q_size):
                cur = queue.popleft()
                if cur.val == val:
                    return cur
                if cur.left: queue.append(cur.left)
                if cur.right: queue.append(cur.right)
        return None

---

LeetCode 98.验证二叉搜索树：

文章链接
题目链接: 98.验证二叉搜索树

思路：

使用中序遍历二叉搜索树得到的数组为有序单增数组。
题目中的坑：
1.递归判断不是判断左孩子节点 < 根节点，右孩子节点 > 根节点就可以的，需要左子树全部节点 < 根节点，右子树全部节点 > 根节点
2.题目所给节点值的范围为int

思路：

1. 中序遍历二叉搜索树，将值记录在数组中，并单独判断数组是否为单增

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        # 对二叉搜索树进行中序遍历得到数组，判断数组是否有序
        self.inNums = []
        self.inorderTraversal(root)
        for i in range(1, len(self.inNums)):
        	# <=，有等于
            if self.inNums[i] <= self.inNums[i - 1]:
                return False
        return True
    def inorderTraversal(self, node):
        if not node:
            return
        self.inorderTraversal(node.left)
        self.inNums.append(node.val)
        self.inorderTraversal(node.right)

2. 遍历过程中判断

#方法1，中序遍历，全局变量记录前一次遍历到的结点，分别判断左子树，当前结点是否为单增，右子树遍历结果是否单增

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        self.pre = None
        return self.inorderTraversal(root)

    def inorderTraversal(self, node):
        if not node:
            return True
        left = self.inorderTraversal(node.left)
        if self.pre and self.pre.val >= node.val:
            return False
        self.pre = node
        right = self.inorderTraversal(node.right)
        return left and right

#方法2：设极小值进行判断，跟方法1相似，pre换成了maxNum
class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        self.maxNum = float('-inf')     # 后台测试数据中有int类型最小值
        return self.inorderTraversal(root)

    def inorderTraversal(self, node):
        if not node:
            return True
        left = self.inorderTraversal(node.left)
        if self.maxNum >= node.val:
            return False
        self.maxNum = node.val
        right = self.inorderTraversal(node.right)
        return left and right

# 方法3：迭代
# 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 isValidBST(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        pre = None
        cur = root
        stack = []
        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()
                if pre and pre.val >= cur.val:
                    return False
                pre = cur
                cur = cur.right
        return True     

感悟:

需要复习中序遍历的非统一迭代算法