刷题---树篇---98. 验证二叉搜索树

98. 验证二叉搜索树

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

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

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/validate-binary-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

_____________________________________________________________________________________________________

验证二叉搜索树，主要是理解bst的性质，左<根<右

方法一：

所以，根据这条性质，中序遍历是一个很好的验证bst的方法，x0<x1<x2...<xn

代码如下：

func isValidBST(root *TreeNode) bool {
    //中序遍历验证bts
    if root == nil {
        return true
    }

    m := make([]int,0)
    count := 0
    res := true

    Run(root,&m,&count,&res)

    return res
}

func Run(root *TreeNode, m *[]int,max *int,flag *bool)  {
    if root == nil || *flag == false {
        return
    }
    
    Run(root.Left,m,max,flag) 
    if len(*m) == 0 {
        *m = append(*m,root.Val)
        *max = root.Val
    } else {
        if *max >= root.Val {
            *flag = false
        }
        *m = append(*m,root.Val)
        *max = root.Val
    }

    Run(root.Right,m,max,flag)
}

使用一个m数组存放中序遍历的结果，flag作为标记，也可以进行剪枝处理。

观察上述代码可以发现，虽然利用了m数组存放所有遍历的结果，但是实际上相比较的就是倒数第一和倒数第二个节点的值，于是可以考虑在空间上进行优化，只用一个遍历存储前一个节点的值。

代码如下：

func isValidBST(root *TreeNode) bool {
    //中序遍历验证bts
    if root == nil {
        return true
    }

    count := 0
    res := true
    max := 0

    Run(root,&count,&max,&res)

    return res
}

func Run(root *TreeNode, count *int,max *int,flag *bool)  {
    if root == nil || *flag == false {
        return
    }
    
    Run(root.Left,count,max,flag) 

    if *count == 0 {
        *max = root.Val
        *count++
    } else {
        if *max >= root.Val {
            *flag = false
        }
        *max = root.Val
    }

    Run(root.Right,count,max,flag)
}

也可用一种更“递归”的思路，即不用额外的变量flag进行标记结果，仅用返回值向上传递结果。但是实际上我认为，只要是方法容易理解、记忆，能够效率较高的解决问题，都是好方法。

代码如下：

func isValidBST(root *TreeNode) bool {
    if root == nil {
        return true
    }
    k := -9999999
    res := Run(root,&k)
    return res
}


func Run(root *TreeNode,k *int) bool {
    if root == nil {
        return true
    }
    l := true
    r := true

    if root.Left != nil {
        l = Run(root.Left,k)
    }


    if *k == -9999999 {
        *k = root.Val
    } else {
        if *k >= root.Val {
            return false
        }
        *k = root.Val
    }

    if root.Right != nil {
        r = Run(root.Right,k)
    }

    return l && r
}

此时就不用flag标记和传递结果，直接利用返回值传递结果。

方法二：

利用bst的性质，根节点总是比左子树的所有值都大，比右子树的所有值都小。

于是可以考虑，用两个变量 up 和 low 分别表示节点所在子树的最大值和最小值。

下一步向右遍历时，保留up,更新low为当前节点;

下一步向左遍历时，保留low，更新up为当前节点.

代码如下：

func isValidBST(root *TreeNode) bool {
    return Run(root,nil,nil)
}

func Run(root , lower , upper *TreeNode) bool {
    if root == nil {
        return true
    }

    if lower != nil && root.Val <= lower.Val {
        return false
    }
    if upper != nil && root.Val >= upper.Val {
        return false
    }

    if !Run(root.Right,root,upper) {
        return false
    }
    if !Run(root.Left,lower,root) {
        return false
    }

    return true
}