二叉搜索树

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。

关键点：空树 每颗子树均满足结点打印左子树上所有的值，均小于右子树上所有结点的值。

一种比较简单的实现方式，就是树的中序遍历结果，是升序就满足条件

    /**
     * 中序升序就是二叉排序树
     */
    private static boolean isBinarySearchTreeV2 (TreeNode<Integer> root) {
        List<Integer> list = in(root);
        if (list==null || list.isEmpty()) return true;

        ArrayList<Integer> arrayList = new ArrayList<>(list);
        int size =  arrayList.size();
        for (int i = 1; i < size; i++) {
            if (arrayList.get(i-1) >= arrayList.get(i) ) {
                return false;
            }
        }

        return true;
    }

    /**
     * 中序遍历
     */
    private static List<Integer> in(TreeNode<Integer> root) {
        if (root == null) {
            return null;
        }

        List<Integer> list = new LinkedList<>();

        List<Integer> leftList = in(root.left);
        if (leftList!=null && !leftList.isEmpty()) {
            list.addAll(leftList);
        }

        list.add(root.val);

        List<Integer> rightList = in(root.right);
        if (rightList!=null && !rightList.isEmpty()) {
            list.addAll(rightList);
        }

        return list;
    }

较为复杂的一种实现方式，每颗子树均满足结点打印左子树上所有的值，均小于右子树上所有结点的值。左子树、右子树、当前树

private static boolean isBinarySearchTree (TreeNode<Integer> root) {
        if (root == null) {
            return true;
        }

        if (root.left == null && root.right==null) return true;

        return processBST(root).isBST;
    }

    private static BinarySearchTreeInfo processBST(TreeNode<Integer> root) {
        if (root == null) {
            /*此时是二叉搜索树
            * 但是最大值最小值返回什么都不合适: 0 结点有负值不合适；int的最大和最小，结点中若有不合适
            * 故不创建对象返回*/
            return null;
        }

        if (root.left == null && root.right==null) {
            return new BinarySearchTreeInfo(true, root.val, root.val);
        }

        BinarySearchTreeInfo leftBinarySearchTreeInfo = processBST(root.left);
        BinarySearchTreeInfo rightBinarySearchTreeInfo = processBST(root.right);
        BinarySearchTreeInfo bstInfo = new BinarySearchTreeInfo(false, root.val, root.val);
        /*（左子树是否满足条件）左子树空 直接就满足二叉搜索，不空取属性
        * （右子树是否满足条件）右子树空 直接就满足二叉搜索 不空取属性
        * （当前树是否满足条件）左子树不空比较结点与左子树的最大值，右子树不空比较右子树的最小值*/
        if ((leftBinarySearchTreeInfo==null || (leftBinarySearchTreeInfo.isBST && root.val>leftBinarySearchTreeInfo.maxValue))
        &&  (rightBinarySearchTreeInfo==null || (rightBinarySearchTreeInfo.isBST && root.val<rightBinarySearchTreeInfo.minValue))) {
            bstInfo.setBST(true);
        }

        if (leftBinarySearchTreeInfo!=null) {
            bstInfo.setMaxValue(Math.max(bstInfo.getMaxValue(), leftBinarySearchTreeInfo.maxValue));
            bstInfo.setMinValue(Math.min(bstInfo.getMinValue(), leftBinarySearchTreeInfo.minValue));
        }

        if (rightBinarySearchTreeInfo!=null) {
            bstInfo.setMaxValue(Math.max(bstInfo.getMaxValue(), rightBinarySearchTreeInfo.getMaxValue()));
            bstInfo.setMinValue(Math.min(bstInfo.getMinValue(), rightBinarySearchTreeInfo.getMinValue()));
        }

        return bstInfo;
    }

    private static class BinarySearchTreeInfo{
        private boolean isBST;//是否二插搜索树
        private int minValue;
        private int maxValue;

        public BinarySearchTreeInfo() {
        }

        public BinarySearchTreeInfo(boolean isBST, int minValue, int maxValue) {
            this.isBST = isBST;
            this.minValue = minValue;
            this.maxValue = maxValue;
        }

        public boolean isBST() {
            return isBST;
        }

        public void setBST(boolean BST) {
            isBST = BST;
        }

        public int getMaxValue() {
            return maxValue;
        }

        public void setMaxValue(int maxValue) {
            this.maxValue = maxValue;
        }

        public int getMinValue() {
            return minValue;
        }

        public void setMinValue(int minValue) {
            this.minValue = minValue;
        }
    }