leetcode98 Validate Binary Search Tree

"""
Given a binary tree, determine if it is a valid binary search tree (BST).
Assume a BST is defined as follows:
    The left subtree of a node contains only nodes with keys less than the node's key.
    The right subtree of a node contains only nodes with keys greater than the node's key.
    Both the left and right subtrees must also be binary search trees.
Example 1:
    2
   / 
  1   3
Input: [2,1,3]
Output: true
Example 2:
    5
   / 
  1   4
     / 
    3   6
Input: [5,1,4,null,null,3,6]
Output: false
Explanation: The root node's value is 5 but its right child's value is 4.
"""
"""
好题，提供四种解法,可与leetcode1305结合起来看https://www.cnblogs.com/yawenw/p/12284717.html
解法一：自己AC 中序遍历(递归） + sorted() + set()
思路是将二叉搜索树中序遍历存入nums
先set()处理，将输入为[1, 1]的情况排除
再sorted()与nums比较是否相等
因为如果为二叉搜索树 nums应该是没有重复值并且递增的
"""
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        if not root:
            return True  # bug input为[]时
        res = self._inorder(root, [])
        return res == sorted(set(res))  # bug 加上set是为了判断input[1,1]

    def _inorder(self, root, nums):
        if root.left:
            self._inorder(root.left, nums)
        nums.append(root.val)
        if root.right:
            self._inorder(root.right, nums)
        return nums
"""
解法二：递归
关键点在于初始化的时候
用无穷大和无穷小作为根结点的上下值
"""
class Solution2:
    def isValidBST(self, root):

        return self._isValidBST(root)

    def _isValidBST(self, root, low=float('-inf'), high=float('inf')): # ！！！关键的初始化
        if not root:
            return True
        value = root.val
        if not low < value < high:
            return False
        return self._isValidBST(root.left, low, value) and 
               self._isValidBST(root.right, value, high)
"""
解法三：将解法一的递归中序遍历变为栈
"""
class Solution3:
    def isValidBST(self, root):
        stack = []
        inorder = []
        if not root:
            return True
        while stack or root: #非递归中序遍历
            while root:
                stack.append(root)
                root = root.left
            root = stack.pop() #bug这里写了 x = stack.pop(),影响上面while循环
            inorder.append(root.val)
            root = root.right #bug 这里写成了stack.append(root.right),原因没理解
        return inorder == sorted(set(inorder))
"""
解法四：将解法二的递归变为迭代(queue)
"""
class Solution4:
    def isValidBST(self, root):
        if not root:
            return True
        queue = [(root, float('-inf'), float('inf'))]
        while queue:
            root, low, high = queue.pop(0)
            value = root.val
            if not low < value < high:
                return False
            if root.left: #if判别不能少
                queue.append((root.left, low, value))
            if root.right:
                queue.append((root.right, value, high))
        return True