【二叉树】leetcode98-验证二叉搜索树

最新推荐文章于 2023-07-04 16:04:18 发布

柒年时光

最新推荐文章于 2023-07-04 16:04:18 发布

阅读量172

点赞数

分类专栏： Python leetcode 文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/jqq125/article/details/121015063

版权

Python 同时被 2 个专栏收录

484 篇文章 1 订阅

订阅专栏

leetcode

461 篇文章 1 订阅

订阅专栏

这篇博客介绍了如何验证一个二叉树是否为有效的二叉搜索树。提供了两种方法，分别是递归的中序遍历和迭代的中序遍历，确保每个节点的值满足左子树所有节点值小于当前节点，右子树所有节点值大于当前节点，并且左右子树自身也必须是二叉搜索树。

摘要由CSDN通过智能技术生成

题目：
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效二叉搜索树定义如下：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
在这里插入图片描述

解答：

方法一：递归
（1）按中序遍历，使用cur_max不断更新最大值，当无法更新时返回False.

# 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:   
        cur_max = -float("INF")
        def traversal(root):
            nonlocal cur_max
            if not root:
                return True
            lv=traversal(root.left)
            #print("before:",cur_max,root.val)
            if root.val>cur_max:
                cur_max=root.val
            else:
                return False
            #print("after:",cur_max,root.val)
            rv=traversal(root.right)
            return lv and rv
        
        return traversal(root)

（2）中序遍历，转换成数组后再判别

# 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 traversal(cur,res):
            if not cur:
                return 
            if cur.left:
                traversal(cur.left,res)
            res.append(cur.val)
            if cur.right:
                traversal(cur.right,res)
        
        res=[]
        traversal(root,res)
        n=len(res)
        for i in range(1,n):
            if res[i-1]>=res[i]:
                return False
        return True

方法二：迭代

（1）中序遍历-一般写法

# 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:   
        stack=[]
        pre,cur=None,root
        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

(2)中序遍历-统一写法

# 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:   
        #中序遍历
        pre=None
        stack=[root]
        while stack:
            cur=stack[-1]
            if cur:
                cur=stack.pop()
                if cur.right:                #右
                    stack.append(cur.right)
                stack.append(cur)            #根
                stack.append(None)
                if cur.left:                 #左
                    stack.append(cur.left)
            else:
                stack.pop()     #弹出空节点
                cur=stack.pop() #处理当前节点
                if pre and pre.val>=cur.val:
                    return False
                pre=cur
        return True