验证二叉搜索树的两种思路及JAVA代码实现

package tree;

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

public class IsValidBSt {
    public static void main(String[] args) {
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(1);
        TreeNode node3 = new TreeNode(3);

        node1.left = node2;
        node1.right = node3;

        IsValidBSt test = new IsValidBSt();

        boolean res = test.isValidBST03(node1);
        System.out.println(res);
    }

    //思路1：递归
    public boolean isValidBST(TreeNode root) {
        return judgeBST(root,null,null);
    }

    /** 功能：判断当前（子）树根节点是否在区间（lower, upper）之间
     *
     * @param node 当前（子）树根节点
     * @param lower 当前（子）树根节点左子结点的值
     * @param upper 当前（子）树根节点右子结点的值
     * @return
     */
    public boolean judgeBST(TreeNode node, Integer lower, Integer upper) {
        if (node == null) {
            return true;
        }
        int val = node.val;
        if (lower != null && val <= lower) {
            return false;
        }
        if (upper != null && val >= upper) {
            return false;
        }

        if (!judgeBST(node.right,val,upper)) {
            return false;
        }
        if (!judgeBST(node.left,lower,val)) {
            return false;
        }

        return true;
    }

    //思路2：根据二叉搜索树的性质，中序遍历得到的序列一定是升序的
    long pre = Long.MIN_VALUE;
    public boolean isValidBST02(TreeNode root) {
        if (root == null) {
            return true;
        }
        //访问左子树
        if (!isValidBST02(root.left)) {
            return false;//说明左子树不是二叉搜索树
        }

        //访问当前结点,如果当前结点的值 小于等于 中序遍历的前一个节点，说明不满足BST，返回 false；否则继续遍历。
        if (root.val <= pre) {
            return false;
        }

        pre = root.val;

        //访问右子树
        return isValidBST02(root.right);
    }

    //也可先将所有的数中序遍历取出放入一个集合中
    public boolean isValidBST03(TreeNode root) {
        if (root == null) {
            return true;
        }

        List<Integer> res = new ArrayList<>();
        infixOrder(root,res);

        for (int i = 0; i < res.size() - 1; i ++) {
            if (res.get(i) < res.get(i + 1)) {
                continue;
            } else {
                return false;
            }
        }

        return true;
    }

    public void infixOrder(TreeNode root, List<Integer> res) {
        //遍历左子树
        if (root.left != null) {
            infixOrder(root.left, res);
        }
        //访问当前结点
        res.add(root.val);

        //遍历右子树
        if (root.right != null) {
            infixOrder(root.right, res);
        }
    }

}