验证二叉搜索树

项目github地址：bitcarmanlee easy-algorithm-interview-and-practice
欢迎大家star，留言，一起学习进步

1.问题描述

给定一个二叉树，判断其是否是一个有效的二叉搜索树（Binary Search Tree)。

一个二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

示例1

输入:
    2
   / \
  1   3
输出: true

示例2

输入:
    5
   / \
  1   4
     / \
    3   6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
     根节点的值为 5 ，但是其右子节点值为 4 。

2.解法一

对树进行中序遍历，将结果保存在temp数组中。如果该temp数组为升序排列，则为BST。

public class TreeNode<T> {

    public T data;

    public TreeNode left;
    public TreeNode right;

    public TreeNode(T data) {
        this.data = data;
    }
}

public class JudgeBST {

    public static List<Integer> datalist = new ArrayList();

    public static TreeNode init() {
        TreeNode root = new TreeNode(2);
        TreeNode left = new TreeNode(1);
        TreeNode right = new TreeNode(3);
        root.left = left;
        root.right = right;
        return root;
    }

    public static TreeNode init2() {
        TreeNode root = new TreeNode(5);
        TreeNode node1 = new TreeNode(1);
        TreeNode node4 = new TreeNode(4);
        TreeNode node3 = new TreeNode(3);
        TreeNode node6 = new TreeNode(6);
        root.left = node1;
        root.right = node4;
        node4.left = node3;
        node4.right = node6;

        return root;
    }


    public static void incData(TreeNode<Integer> root) {
        if (root != null) {
            incData(root.left);
            datalist.add(root.data);
            incData(root.right);
        }
    }

    public static boolean isBST() {
        boolean flag = true;
        for(int i=0; i<datalist.size()-1; i++) {
            if (datalist.get(i) > datalist.get(i+1)) {
                flag = false;
                break;
            }
        }
        return flag;
    }

    public static void main(String[] args) {
        TreeNode root = init2();
        //TreeNode root = init();
        incData(root);
        boolean result = isBST();
        System.out.println(result);
    }

}

3.解法二

二叉搜索树当前节点是左子树的最大值，是右子树的最小值，可以采用基于前序遍历的递归方式。

    public static boolean search(TreeNode<Integer> root) {
        if(root == null) {
            return true;
        }
        return search(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
    }

    public static boolean search(TreeNode<Integer> root, int minValue, int maxValue) {
        if(root == null) {
            return true;
        }

        if(root.data <= minValue || root.data >= maxValue) {
            return false;
        }

        return search(root.left, minValue, root.data) && search(root.right, root.data, maxValue);
    }

4.解法三

public class JudgeBST3 {

    public static boolean failed = false;
    public static int minvalue = Integer.MIN_VALUE;

    public static TreeNode init2() {
        TreeNode root = new TreeNode(5);
        TreeNode node1 = new TreeNode(1);
        TreeNode node4 = new TreeNode(4);
        TreeNode node3 = new TreeNode(3);
        TreeNode node6 = new TreeNode(6);
        root.left = node1;
        root.right = node4;
        node4.left = node3;
        node4.right = node6;

        return root;
    }

    public static void inOrder(TreeNode<Integer> root) {
        if (root == null || failed) {
            return;
        }

        inOrder(root.left);
        if (minvalue > root.data) {
            failed = true;
        }
        minvalue = root.data;
        inOrder(root.right);
    }

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

        inOrder(root);
        return !failed;
    }

    public static void main(String[] args) {
        TreeNode<Integer> root = init2();
        boolean result = isBst(root);
        System.out.println(result);
    }
}