leetcode 98. validate-binary-search-tree 验证二叉搜索树 python3

时间：2020-9-18

题目地址：https://leetcode-cn.com/problems/validate-binary-search-tree/

题目难度：Medium

题目描述：

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1:

输入:
    2
   / \
  1   3
输出: true
示例 2:

输入:
    5
   / \
  1   4
     / \
    3   6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
     根节点的值为 5 ，但是其右子节点值为 4 。

---

思路1：利用二叉搜索树中序遍历的特性

代码段1：通过

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        res = []
        def inOrderVisit(root):
            if root:
                inOrderVisit(root.left)
                res.append(root.val)
                inOrderVisit(root.right)
        inOrderVisit(root)
        return res == sorted(res) and len(res) == len(set(res))

总结：

1. 第一次写的时候忘记了一个重要的点，二叉搜索树中是不存在重复的val相同的结点的，一开始写的是 res == sorted(list(set(res))) 后来看别人写的更优雅，就优化了一下

---

思路2：利用最大值和最小值的特性

• 对于根节点，它的上下限为无穷大和无穷小
• 边界条件，如果node为空肯定是二叉搜索树
• 如果当前节点超出上下界范围，肯定不是【二叉搜索树的前两个条件】
• 递归判断当前节点的左右子树是否同时是二叉搜索树即可

代码段2：通过

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        def inOrderVisit(node, min_val, max_val):
            if not node:
                return True 
            if not min_val < node.val < max_val:
                return False
            return inOrderVisit(node.left, min_val, node.val) and inOrderVisit(node.right, node.val, max_val)
        return inOrderVisit(root, float('-inf'), float('inf'))

总结：

1. 这很厉害，思路清晰啊，惭愧惭愧

2021-01-31

看labuladong的文章写的，通过增加参数，将二叉树的约束传递到左右子树

# 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: TreeNode) -> bool:
        def traverse(root, min, max):
            if root == None:
                return True
            if max != None and root.val >= max.val:
                return False
            if min != None and root.val <= min.val:
                return False
            return traverse(root.left, min, root) and traverse(root.right, root, max)

        return traverse(root, None, None)

总结：

1. 这里还是通用的模板，方便记忆

---

思路3：递归

代码段3：通过

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        self.pre = None
        def isBSF(root):
            if not root:
                return True
            if not isBSF(root.left):
                return False
            if self.pre and self.pre.val >= root.val:
                return False
            self.pre = root
            return isBSF(root.right)
        return isBSF(root)

总结：

1. 递归还是不行啊，我的妈，

2. 四步递归：递归终结条件√、处理当前层逻辑√、下探到下一层、清理当前层

---

思路4：迭代

代码段4：通过

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        stac = []
        p = root
        pre = None
        while p or stac:
            while p:
                stac.append(p)
                p = p.left
            p = stac.pop()
            if pre and p.val <= pre.val:
                return False
            pre = p
            p = p.right
        return True          

总结：

1. 迭代和递归思路很像，还是不会