98验证二叉搜索树

验证二叉搜索树

https://leetcode-cn.com/problems/validate-binary-search-tree/

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

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

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

Version1：递归

public class BST {
    public boolean isValidBST(TreeNode root){
        return process(root).isBST;
    }
    public static class Info{
        Boolean isBST;
        int max;
        int min;
        public Info(Boolean isBST,int max,int min){
            this.isBST =isBST;
            this.max=max;
            this.min=min;
        }
    }
    //isBST设置为false,
    /*public Info process(TreeNode root){
        if(root==null){
            return null;
        }
        Info leftInfo=process(root.left);
        Info rightInfo=process(root.right);
        int max=root.val;
        int min=root.val;
        if(leftInfo!=null){
            max=Math.max(leftInfo.max,max);
            min=Math.min(leftInfo.min,min);
        }
        if(rightInfo!=null){
            max=Math.max(rightInfo.max,max);
            min=Math.min(rightInfo.min,min);
        }
        Boolean isBST=false;
        Boolean leftIsBST=leftInfo==null?true:leftInfo.isBST;
        Boolean rightIsBst=rightInfo==null?true:rightInfo.isBST;
        Boolean leftMaxLessX=leftInfo==null?true:(leftInfo.max<root.val);
        Boolean rightMinMoreX=rightInfo==null?true:(rightInfo.min>root.val);
        //只有当左子树是二叉搜索树，右子树是二叉搜索树，左子树的最大值小于根节点，右子树的最小值小于根节点，这四种情况同时满足，返回true。
        if(leftIsBST&&rightIsBst&&leftMaxLessX&&rightMinMoreX){
            isBST=true;
        }
        return new Info(isBST,max,min);
    }*/
    //isBST设置为true
    public Info process(TreeNode root){
        //此处并没有返回Info对象，因为如果return new Info(true,max,min)，其中max和min的值无法确定。
        //此处return null，交给上游程序进行处理。
        if(root==null){
            return null;
        }
        Info leftInfo=process(root.left);
        Info rightInfo=process(root.right);
        int max=root.val;
        int min=root.val;
        //求得左子树+根节点的最小值和最大值。
        if(leftInfo!=null){
            max=Math.max(leftInfo.max,max);
            min=Math.min(leftInfo.min,min);
        }
        //求得左子树+根节点+右子树的最小值和最大值。
        if(rightInfo!=null){
            max=Math.max(rightInfo.max,max);
            min=Math.min(rightInfo.min,min);
        }
        Boolean isBST=true;
        //不是搜索树的4种情况。
        //情况1：左子树不为空，左子树不是搜索二叉树。
        if(leftInfo!=null&&leftInfo.isBST==false){
            isBST=false;
        }
        //情况2：右子树不为空，右子树不是搜索二叉树。
        if(rightInfo!=null&&rightInfo.isBST==false){
            isBST=false;
        }
        //情况3：左子树不为null，左子树的最大值不小于根节点的值
        //情况4：右子树不为null，右子树的最小值不大于根节点的值
        Boolean leftMaxLessX=leftInfo==null?true:(leftInfo.max<root.val);
        Boolean rightMinMoreX=rightInfo==null?true:(rightInfo.min>root.val);
        if(!leftMaxLessX||!rightMinMoreX){
            isBST=false;
        }
        return new Info(isBST,max,min);
    }
}

Version2 中序遍历

如果中序遍历的结果是有序的，则该二叉树是一棵搜索二叉树

public class BST2 {
    LinkedList<Integer> list=new LinkedList<>();
    public boolean isValidBST(TreeNode root){
        inorderTraversal(root);
        if(list.size()<2){
            return true;
        }
        //验证中序遍历的结果是有序的
        for(int i=1;i<list.size();){
            int x=list.poll();
            int y=list.peek();
            if(x>y){
                return false;
            }
        }
        return true;
    }
    //得到中序遍历的结果
    public LinkedList<Integer> inorderTraversal(TreeNode root) {
        inOrder(root,list);
        return list;

    }
    public void inOrder(TreeNode root,LinkedList list){
        if(root==null){
            return;
        }
        inorderTraversal(root.left);
        list.add(root.val);
        inorderTraversal(root.right);
    }

}