算法(TS)：验证二叉搜索树

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

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

示例

示例一

示例一是有效的二叉搜索树

示例二

示例二不是有效的二叉搜索树，因为根节点的值是 5 ，但是右子节点的值是 4 。

提示：

树中节点数目范围在[1, 104] 内
-231 <= Node.val <= 231 - 1****

解答

解答一

有效的二叉搜索树中每一个节点都有一个最大取值和最小取值，以示例二来说，假设我们要将它变成有效二叉搜索树，那么，顶层节点【5】的取值范围是(-Infinity,Infinity)，第一层的左节点【1】的取值范围是(-Infinity,5)，第一层的右节点【4】的取值范围是(5,Infinity)；接下来分享第三层，第三层【3】的取值范围是(【4】的最小取值，【4】的值)，第三层【6】的取值范围是(【4】的值，【4】的最大取值，即Infinity)。

使用递归解法如下：

kotlin 复制代码

/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */

function isValidBST(root: TreeNode | null): boolean {
    const isValid = (root:TreeNode | null,minVal: number,maxVal: number) => {
        if (!root) return true
        if (root.val <= minVal || root.val >= maxVal) {
            return false
        }
        return isValid(root.left,minVal,root.val) && isValid(root.right,root.val,maxVal)
    }
    return isValid(root,-Infinity,Infinity)
};

时间复杂度O(n)，空间复杂度O(n)

解答二

进行中序优先遍历，如果是有效的二叉搜索树，那么上一个节点的值一定小于当前节点的值，否则不是有效的二叉搜索树。

ini 复制代码

/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */

function isValidBST(root: TreeNode | null): boolean {
    let prevVal = -Infinity
    const stack: TreeNode[] = []
    while(root || stack.length) {
        while(root) {
            stack.push(root)
            root = root.left
        }

        root = stack.pop()
        if (root.val <= prevVal) {
            return false
        }

        prevVal = root.val
        root = root.right
    }

    return true
};

时间复杂度O(n)，空间复杂度O(n)