03、二叉树的递归套路-二叉搜索树

题目：

给定一棵二叉树的头节点head，返回这颗二叉树是不是搜索二叉树

 搜索二叉树定义：

1、解决方案1：

1.1、思路：

1、中序遍历该树，把遍历到的节点保存到集合中
2、遍历集合，如果该树是二叉搜索树，那么一定满足索引i位置元素一定是大于索引(i-1)位置的元素值

1.2、代码：

public static class Node {
    public int value;
    public Node left;
    public Node right;

    public Node(int data) {
        this.value = data;
    }
}

//方案1: 利用中序遍历来判断该树是否为搜索二叉树
public static boolean isBST1(Node head) {
    if (head == null) {
        return true;
    }
    ArrayList<Node> arr = new ArrayList<>();
    in(head, arr);
    //中序遍历之后，得到集合arr，然后遍历arr
    //如果该树是二叉搜索树，那么一定满足索引i位置元素一定是大于索引(i-1)位置的元素值
    for (int i = 1; i < arr.size(); i++) {
        if (arr.get(i).value <= arr.get(i - 1).value) {
            return false;
        }
    }
    return true;
}

//中序遍历该树，然后把遍历到的数据都加入到集合中
public static void in(Node head, ArrayList<Node> arr) {
    if (head == null) {
        return;
    }
    in(head.left, arr);
    arr.add(head);
    in(head.right, arr);
}

 2、解决方案2

2.1、思路：

1、向左右子树分别要信息
2、返回左子树是否为搜索二叉树以及最小、最大值，右子树是否为搜索二叉树以及最小、最大值
3、最后根据信息来判断

 2.2、代码：

//方案2：
public static boolean isBST2(Node head) {
    if (head == null) {
        return true;
    }
    return process(head).isBST;
}

public static class Info {
    //以该节点为头部的子树是否为二叉搜索树
    boolean isBST;
    //该子树上的最小值
    public int min;
    //该子树上的最大值
    public int max;

    public Info(boolean is, int mi, int ma) {
        isBST = is;
        min = mi;
        max = ma;
    }
}

public static Info process(Node head) {
    if (head == null) {
        return null;
    }
    //当前节点左子树信息
    Info leftInfo = process(head.left);
    //当前节点右子树信息
    Info rightInfo = process(head.right);
    int min = head.value;
    int max = head.value;
    if (leftInfo != null) {
        min = Math.min(min, leftInfo.min);
        max = Math.max(max, leftInfo.max);
    }
    if (rightInfo != null) {
        min = Math.min(min, rightInfo.min);
        max = Math.max(max, rightInfo.max);
    }
    boolean isBST = false;
    if (
        //左子树为空，或 左子树是搜索二叉树且此子树最大值小于当前节点值
            (leftInfo == null ? true : (leftInfo.isBST && leftInfo.max < head.value))
                    &&
                    //右子树为空，或 右子树是搜索二叉树且此子树最小值大于当前节点值
                    (rightInfo == null ? true : (rightInfo.isBST && rightInfo.min > head.value))
    ) {
        //如果都满足，那么以当前节点为头节点的子树就是一个搜索二叉树
        isBST = true;
    }
    return new Info(isBST, min, max);
}