LeetCode98-验证二叉搜索树

原题链接：https://leetcode-cn.com/problems/validate-binary-search-tree/

二叉搜索树的性质：二叉树中序遍历的结果为递增序列

解法一：采用递归法中序遍历，比较相邻节点的大小

# 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 __init__(self):
        self.pre_value = float('-inf')
    
    def isValidBST(self, root: TreeNode) -> bool:
        return self.checkBST(root)
    
    def checkBST(self, head: TreeNode) -> bool:
        if head is None:
            return True
        is_left_bst = self.checkBST(head.left)
        if not is_left_bst:
            return False
        if head.val <= self.pre_value:
            return False
        else:
            self.pre_value = head.val
        return self.checkBST(head.right)

解法二：采用栈的方式中序遍历，比较相邻节点的大小

# 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
from collections import deque
class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        if root is None:
            return True
        pre_value = float('-inf')
        stack = deque()
        while stack or root is not None:
            if root is not None:
                stack.append(root)
                root = root.left
            else:
                root = stack.pop()
                if root.val <= pre_value:
                    return False
                else:
                    pre_value = root.val
                root = root.right
        return True

解法三：

递归求解：左树和右树都为搜索二叉树，且左树的最大值小于root的值，右树的最小值大于root的值

 1 # Definition for a binary tree node.
 2 # class TreeNode:
 3 #     def __init__(self, val=0, left=None, right=None):
 4 #         self.val = val
 5 #         self.left = left
 6 #         self.right = right
 7 class ReturnData:
 8     def __init__(self, is_BST, min_val, max_val):
 9         self.is_BST = is_BST
10         self.min_val = min_val
11         self.max_val = max_val
12 
13 class Solution:
14     def isValidBST(self, root: TreeNode) -> bool:
15         return self.process(root).is_BST
16     
17     def process(self, x: TreeNode) -> ReturnData:
18         if not x:
19             return None
20         leftData = self.process(x.left)
21         rightData = self.process(x.right)
22         min_val = x.val
23         max_val = x.val
24         if leftData:
25             min_val = min(min_val, leftData.min_val)
26             max_val = max(max_val, leftData.max_val)
27         if rightData:
28             min_val = min(min_val, rightData.min_val)
29             max_val = max(max_val, rightData.max_val)
30         is_BST = True
31         if leftData and (not leftData.is_BST or leftData.max_val >= x.val):
32             is_BST = False
33         if rightData and (not rightData.is_BST or x.val >= rightData.min_val):
34             is_BST = False
35         return ReturnData(is_BST, min_val, max_val)

 

类似的题：面试题 04.05. 合法二叉搜索树

原题链接：https://leetcode-cn.com/problems/legal-binary-search-tree-lcci/

代码：

 1 # Definition for a binary tree node.
 2 # class TreeNode:
 3 #     def __init__(self, x):
 4 #         self.val = x
 5 #         self.left = None
 6 #         self.right = None
 7 class Solution:
 8     def __init__(self):
 9         self.pre_value = float('-inf')
10     
11     def isValidBST(self, root: TreeNode) -> bool:
12         return self.checkBST(root)
13     
14     def checkBST(self, head: TreeNode) -> bool:
15         if head is None:
16             return True
17         is_left_bst = self.checkBST(head.left)
18         if not is_left_bst:
19             return False
20         if head.val <= self.pre_value:
21             return False
22         else:
23             self.pre_value = head.val
24         return self.checkBST(head.right)

 

posted @ 2022-01-11 22:00  CaptainDragonfly  阅读(27)  评论(0)    收藏  举报