判断搜索二叉树

import java.util.ArrayList;
import java.util.Stack;

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

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

    public static int preValue = Integer.MIN_VALUE;

    public static boolean checkBST(Node head){
        if(head == null){
            return true; 
        }
        boolean isLeftBst = checkBST(head.left);
        if(!isLeftBst){
            return false;//如果左树不是搜索二叉树，那么就不用往下看了
        }
        if(head.value <= preValue){//如果左树最后处理的一个节点比根节点大，也不用再看了
            return false;
        }else{
            preValue = head.value;//本质上是中序遍历，这一步为处理节点的那一步
        }
        return checkBST(head.right);//如果右树也是搜索二叉树那整棵树都是，如果右树不是那就不是

    }

    public static boolean isBST1(Node head){//非递归的方式实现
        if(head == null){
            return true;
        }
        ArrayList<Node> arr = new ArrayList<>();
        in(head,arr);
        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);
    }

    public static boolean isBST2(Node head){//非递归的方式实现
        if(head != null){
            Stack<Node> stack = new Stack<>();
            int preValue = Integer.MIN_VALUE;
            while(!stack.isEmpty() || head != null){//head复用了
                if(head != null){
                    stack.push(head);
                    head = head.left;
                }else{
                    head = stack.pop();
                    if(preValue < head.value){
                        return false;
                    }else{
                        preValue = head.value;
                    }
                    head = head.right;
                }
            }
        }
        return true;
    }
}

总共4种方法，两种递归，2种非递归的
核心思路就是中序遍历二叉树，看是否是升序的
在中序遍历处理节点的那一步进行值比较

新加一种二叉树的递归套路

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

		public Node(int data) {
			this.value = data;
		}
	}
  
    public static class Info{//收集信息，1.该树是不是BST 2.该树左树的最大值（因为要求左树最大值小于我）
        public boolean isBST;//3.该树右树的最小值（因为要求右树的最小值大于我）
        public int min;//由于左右两树收集的信息不完全一样，去并集，最小值最大值都收集
        public int max;
        
        public Info(boolean i,int mi,int ma){
            isBST = i;
            min = mi;
            max = ma;
        }
    }
    public static Info process(Node x){
        if(x == null){
            return null;//由于此时为空,Info的isBST虽然能设置为true，但是Min和max不好给值,所以先返回空给下面处理
        }
        Info lefInfo = process(x.left);//收集左树的信息
        Info righInfo = process(x.right);//收集右树的信息

        boolean isBST;//自己也要返回三个信息
        int min;
        int max;

        min = x.value;
        max = x.value;
        if(lefInfo != null){
            min = Math.min(min,lefInfo.min);
            max = Math.max(max,lefInfo.max);
        }
        if(righInfo != null){
            min = Math.min(min, righInfo.min);
            max = Math.max(max, righInfo.max);
        }

        isBST = true;//先设置为true，如果违规设置为false
        if(lefInfo != null && (!lefInfo.isBST || lefInfo.max >= x.value)){
            isBST = false;
        }
        if(righInfo != null && (!righInfo.isBST || righInfo.min <= x.value )){
            isBST = false;
        }

        return new Info(isBST,min,max);
    }

    
 
}