leetcode 98. 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.

思路：

二叉排序树的中序遍历是一个升序序列，所以我们只需要对二叉树进行中序遍历，在遍历过程中对比当前值和前一个值是否满足递增即可。

实现1：traverse

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    //二叉搜索树中序遍历的结果是升序序列
    TreeNode last=null;
    public boolean isValidBST(TreeNode root) {
        if(root==null){
            return true;
        }
        //遍历左子树
        if(!isValidBST(root.left)){
            return false;
        }
        //处理根节点
        if(last!=null&&last.val>=root.val){
            return false;
        }
        last=root;
        //遍历右子树
        if(!isValidBST(root.right)){
            return false;
        }
        return true; 
    }
}

实现2：分治

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class ResultType{
    boolean is_bst;
    int maxValue,minValue;
    ResultType(boolean is_bst,int maxValue,int minValue){
        this.is_bst=is_bst;
        this.maxValue=maxValue;
        this.minValue=minValue;
    }
}
class Solution {
    //分治法
    public boolean isValidBST(TreeNode root) {
        ResultType r=fun(root);
        return r.is_bst;
        
    }
    private ResultType fun(TreeNode root){
        if(root==null){
            return new ResultType(true,Integer.MIN_VALUE,Integer.MAX_VALUE);
        }
        ResultType left=fun(root.left);
        ResultType right=fun(root.right);
        if(!left.is_bst||!right.is_bst){
            return new ResultType(false,0,0);
        }
        if(root.left!=null&&left.maxValue>=root.val||root.right!=null&&right.minValue<=root.val){
            return new ResultType(false,0,0);
        }
        return new ResultType(true,Math.max(root.val,right.maxValue),Math.min(root.val,left.minValue));
    }
}