递归套路--判断是否是搜索二叉树，暴力方法对数器

定义

   左树的最大节点比头结点小，右树的最小节点比头结点大
   延伸出来的含义：中序遍历单调递增

套路 ： isBST2()方法

递归套路：
 *      1.收集左右树的最大最小节点
 *      2.和头结点对比
 *  信息收纳：
 *      最大节点
 *      最小节点

对数器：isBST()方法

	利用中序遍历的特性判断集合单调递增

package cn.bugstack.session;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description TODO
 * @ClassName Code09_SearchTree
 * @Author bzh
 * @Version 1.0.0
 * @CreateTime 2023-08-24 9:42 - 星期四
 */
public class Code09_SearchTree {
    static class Node{
        int val;
        Node left;
        Node right;

        public Node(int val) {
            this.val = val;
        }

    }
    static class Info{
        boolean isSearch;
        int max;
        int min;

        public Info(boolean isSearch, int max, int min) {
            this.isSearch = isSearch;
            this.max = max;
            this.min = min;
        }
    }

    //暴力方法,使用中序遍历；搜索树中序，单调递增
    public static boolean isBST1(Node head){
        if(head==null)return true;
        List<Node> arr = new ArrayList<>();
        in(head,arr);
        for (int i = 1; i < arr.size(); i++) {
            if(arr.get(i).val<=arr.get(i-1).val){
                return false;
            }
        }
        return true;
    }
    public static void in(Node head,List<Node> arr){
        if(head==null)return;
        in(head.left,arr);
        arr.add(head);
        in(head.right,arr);
    }
/**
     * 论证：左树最大节点 < 头结点，右树最小节点 > 头结点
     *
     * 递归套路：
     *      1.收集左右树的最大最小节点
     *      2.和头结点对比
     *  信息收纳：
     *      最大节点
     *      最小节点
     *
     *
     */
    public static boolean isBST2(Node head){
        if(head==null)return true;
        return process(head).isSearch;
    }
    public static Info process(Node head){
        if(head==null)return null;
        Info leftInfo = process(head.left);
        Info rightInfo = process(head.right);
        //收集信息
        int max= head.val;
        int min = head.val;
        if(leftInfo!=null){
            max=Math.max(max, leftInfo.max);
            min=Math.min(min, leftInfo.min);
        }
        if(rightInfo!=null){
            max=Math.max(max, rightInfo.max);
            min=Math.min(min, rightInfo.min);
        }
        boolean isBST = true;
        if(leftInfo!=null && !leftInfo.isSearch){
            isBST=false;
        }
        if(rightInfo!=null && !rightInfo.isSearch){
            isBST=false;
        }
        if(leftInfo!=null && head.val<= leftInfo.max){
            isBST=false;
        }
        if(rightInfo!=null && head.val>= rightInfo.min){
            isBST=false;
        }
        return new Info(isBST,max,min);
    }
    public static Node generateRandomNode(int maxLevel,int maxValue){
        return generate(1,maxLevel,maxValue);
    }
    public static Node generate(int level,int maxLevel,int maxValue){
        if(level>maxLevel || Math.random()<=0.5){
            return null;
        }
        Node head = new Node((int) (Math.random() * maxLevel));
        head.left=generate(level+1,maxLevel,maxValue);
        head.right=generate(level+1,maxLevel,maxValue);
        return head;
    }
    public static void main(String[] args) {
        int maxLevel=5;
        int maxValue=1000;
        int testTimes=1000000;
        for (int i = 0; i < testTimes; i++) {
            Node node = generateRandomNode(maxLevel, maxValue);
            if(isBST1(node)!=isBST2(node)){
                System.out.println("Oop");
            }
        }
    }
}