面试题 04.05. 合法二叉搜索树

题目

实现一个函数，检查一棵二叉树是否为二叉搜索树。

---

解题思路

1.二叉排序树的中序遍历是有序且递增的

• 在总结树前中后序特点的最后总结过。
• 补充一个知识点

二叉排序树（Binary Sort Tree）或者是一棵空树；或者是具有下列性质的二叉树：
若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若右子树不空，则右子树上所有结点的值均大于它的根结点的值；
左、右子树也分别为二叉排序树；
没有键值相等的节点；
在经典教材《数据结构》严蔚敏 著 一书中 是不允许出现键值相同的节点的

• 因此排序后，检查数组的时候，还要看看相邻节点值是否相等！

代码：

class Solution {
    public List<Integer> list ;

    public boolean isValidBST(TreeNode root) {
        this.list = new ArrayList<>();
        inOrder(root);
        if (list.size() == 0){
            return true;
        }
        for (int i = 0; i < list.size()-1; i++) {
            if (list.get(i) >= list.get(i+1)){ // 注意这里是>= 因为数据结构中定义的二叉排序树没有相同的节点...
                return false;
            }
        }
        return true;
    }
    public void inOrder(TreeNode node){
        if (node==null){
            return;
        }
        inOrder(node.left);
        list.add(node.val);
        inOrder(node.right);
    }
}

性能：

• 每次使用先序遍历在判断的时候，时间复杂度就不好，因为先序遍历将所有节点都遍历了…应该作为下下策
  

---

2.对中序遍历进行一些改进，维护一个状态值

思路：

• 不在将其序列放到StringBuilder中，而是维护一个状态值
• 如果前序的元素pre大于等于后序元素，那么status置为false；最后检查status在中序遍历的过程中有没有变为false即可。
• 【注意】第一次对比的时候，我将pre置位Integer.MIN_VALUE，但是如果第一个元素的大小就是MIN_VALUE的话，对比会出bug，因此在维护一个count，count为0的之后是中序第一个数据，做特殊处理！

代码：

class Solution {
    public static void main(String[] args) {
        TreeNode head = new TreeNode(Integer.MAX_VALUE);
        head.right = new TreeNode(Integer.MIN_VALUE);
        Solution solution = new Solution();
        System.out.println(solution.isValidBST(head));
    }

    public int pre;
    public boolean status;
    public boolean flag = true;

    public boolean isValidBST(TreeNode root) {
        if (root == null || root.left == null && root.right == null) {
            return true;
        }

        status = true; //遍历的时候查看有没有逆序的
        pre = Integer.MIN_VALUE;
        inOrder(root);
        return status;
    }

    public void inOrder(TreeNode node) {
        if (node == null) {
            return;
        }
        inOrder(node.left);
        if (pre >= node.val) {
            status = false;
            if (flag && node.val == Integer.MIN_VALUE){
                status = true;
                flag = false;
            }
        }
        flag = false;
        pre = node.val;

        inOrder(node.right);
    }
}

性能：

---

3.能否中序遍历的途中发现立即返回false，而不是遍历完再查看

• 就是中序遍历的时候，将每个结果记在list中
• 每次记的时候，检查这个元素跟前一个元素的关系，是否符合2叉排序树的特征
• 如果不符合将res置位false；
• 每次放完之后立马检查res是否为false，如果是则返回false；

代码：

class Solution {
    public static void main(String[] args) {
        TreeNode head = new TreeNode(Integer.MAX_VALUE);
        head.right = new TreeNode(Integer.MIN_VALUE);
        Solution solution = new Solution();
        System.out.println(solution.isValidBST(head));
    }

    public boolean res = true;
    
    private List<Integer> list = new ArrayList<>();

    public boolean isValidBST(TreeNode root) {
        if (root == null){
            return true;
        }
        isValidBST(root.left);
        check(root.val);
        if (!res){
            return false;
        }
        isValidBST(root.right);
        return res;
    }
    public void check(int val){
        if (list.isEmpty()){
            list.add(val);
        }else{
            list.add(val);
            if (list.get(list.size()-1)<=list.get(list.size()-2)){
                res = false;
            }
        }
    }
}

性能：
时间反而增加了？这种做法应该不用遍历整个数，只要找到不符合的就直接返回false，讲道理应该比方法2（遍历完再看status）要快一些

---

4.递归

思路：

• 我之前一直在担心第一个节点会不会是Integer.MIN_VALUE，但是下面这种方法可以避开这个坑，因为它直接将边界订到Long.MIN_VALUE 和 Long.MAX_VALUE。
• 这个做法会随着递归，不断收缩控制子树节点应在的区间（收缩上下限）
• 因为按照二叉排序树的说法，左子树的所有节点需要小于根节点，右子树下的所有节点要大于根节点
• 通过下面代码这种方式，除非左子树中有一个节点不在这个范围则直接返回false；

代码：

public class Solution{
    public boolean isValidBST(TreeNode root) {
        return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }

    public boolean isValidBST(TreeNode root, long minVal, long maxVal) {
        if (root == null)
            return true;
        //每个节点如果超过这个范围，直接返回false
        if (root.val >= maxVal || root.val <= minVal)
            return false;
        //这里再分别以左右两个子节点分别判断，
        //左子树范围的最小值是minVal，最大值是当前节点的值，也就是root的值，因为左子树的值要比当前节点小
        //右子数范围的最大值是maxVal，最小值是当前节点的值，也就是root的值，因为右子树的值要比当前节点大
        return isValidBST(root.left, minVal, root.val) && isValidBST(root.right, root.val, maxVal);
    }
}

---