lc_dfs_98_isValidBST

题目：验证二叉搜索树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：
    节点的左子树只包含小于当前节点的数。
    节点的右子树只包含大于当前节点的数。
    所有左子树和右子树自身必须也是二叉搜索树。

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

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

 

思路：
详情请参见：判断一棵树是否为SBT
1)递归：dfs
2)中序遍历：又分为递归和非递归两种

 

 

package leetCode.DFS;

import java.util.Stack;

public class lc_dfs_98_isValidBST {


/*
    public static void main(String[] args) {
        TreeNode node1 = new TreeNode(10);
        TreeNode node2 = new TreeNode(4);
        TreeNode node3 = new TreeNode(15);
        TreeNode node4 = new TreeNode(14);
        TreeNode node5 = new TreeNode(20);
        node1.left = node2;
        node1.right = node3;
        node3.left = node4;
        node3.right = node5;
        lc_dfs_98_isValidBST m = new lc_dfs_98_isValidBST();
        System.out.println(m.isValidBST(node1));
    }*/

    /*
    思路1：递归dfs
     */
    public boolean isValidBST(TreeNode root) {
        if (root == null)
            return true;

        return dfs(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }

    /**
     * @param root
     * @param leftLimit  结点值的左边界
     * @param rightLimit 结点值的右边界
     * @return
     */
    public boolean dfs(TreeNode root, long leftLimit, long rightLimit) {
//        无节点了，到底了，返回true
        if (root == null)
            return true;
//      如果不在区间内，说明不是二叉搜索树
        if (root.val <= leftLimit || root.val >= rightLimit)
            return false;
//       注意左右结点的区间设置不同，可以枚举下各左右结点的区间，
//       就可以得出左右子节点leftLimit和rightLimit
        return dfs(root.left, leftLimit, root.val) && dfs(root.right, root.val, rightLimit);

    }

    /*
    中序遍历：非递归方式

     */
    public boolean isValidBST2(TreeNode root) {
        if (root == null)
            return true;

        Stack<TreeNode> stack = new Stack<>();
        long lastValue = Long.MIN_VALUE;
        while (root != null || !stack.isEmpty()) {
//            不为空压栈
            if (root != null) {//不断将左子树结点都压进去
                stack.push(root);
                root = root.left;
            } else {//root为空stack不为空出栈并访问
                TreeNode node = stack.pop();//从最后的左子树结点开始访问
//       判断部分:BST输出是递增的，如果当前值比前一个结点更小，说明不是BST
                if (node.val <= lastValue)
                    return false;
                else {
                    lastValue = node.val;
//        一旦node右结点不为空，继续将其放入栈中，接着找到右结点全部的左子结点，
//         即中序遍历poll的右子树
                    root = node.right;
                }
            }

        }
        return true;
    }


    /*
    中序遍历：递归方式
     */

    //    preval记录上个结点的值，注意是成员变量不是局部变量，保证在递归中变量值的实时变化
    long lastVal = Long.MIN_VALUE;

    public boolean isValidBST3(TreeNode root) {
        if (root == null)
            return true;
        boolean leftCheck = isValidBST3(root.left);
        if (root.val <= lastVal)
            return false;
        else
            lastVal = root.val;
        boolean rightCheck = isValidBST3(root.right);
        return leftCheck && rightCheck;

    }


}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}