LeetCode: Validate Binary Search Tree 解题报告

Validate Binary Search Tree

Given a binary tree, determine if it is a valid binary search tree (BST).

Assume a BST is defined as follows:

The left subtree of a node contains only nodes with keys less than the node's key.
The right subtree of a node contains only nodes with keys greater than the node's key.
Both the left and right subtrees must also be binary search trees.
confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

SOLUTION 1:

使用Iterator 中序遍历的方法，判断整个数列是否保持增序即可。

算法思想：

http://www.cnblogs.com/shuaiwhu/archive/2011/04/20/2065055.html

1.采用栈的话，先寻找最左边的节点，把经过的节点都存入栈中，第一个被弹出来的为最左节点，那么访问其右子树，对右子树也像前面一样遍历，整个流程跟递归一样。

public boolean isValidBST1(TreeNode root) {
        // Just use the inOrder traversal to solve the problem.
        if (root == null) {
            return true;
        }
        
        Stack<TreeNode> s = new Stack<TreeNode>();
        TreeNode cur = root;
        
        TreeNode pre = null;
        
        while(true) {
            // Push all the left node into the stack.
            while (cur != null) {
                s.push(cur);
                cur = cur.left;
            }
            
            if (s.isEmpty()) {
                break;
            }
            
            // No left node, just deal with the current node.
            cur = s.pop();
            
            if (pre != null && pre.val >= cur.val) {
                return false;
            }
            
            pre = cur;
            
            // Go to the right node.
            cur = cur.right;
        }
        
        return true;
    }

SOLUTION 2:

引自大神的思想：http://blog.csdn.net/fightforyourdream/article/details/14444883

我们可以设置上下bound，递归左右子树时，为它们设置最大值，最小值，并且不可以超过。

注意：下一层递归时，需要把本层的up 或是down继续传递下去。相当巧妙的算法。

/*
        SOLUTION 2: Use the recursive version.
        REF: http://blog.csdn.net/fightforyourdream/article/details/14444883
    */
    public boolean isValidBST2(TreeNode root) {
        // Just use the inOrder traversal to solve the problem.
        if (root == null) {
            return true;
        }
        
        return dfs(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }
    
    public boolean dfs(TreeNode root, long low, long up) {
        if (root == null) {
            return true;
        }
        
        if (root.val >= up || root.val <= low) {
            return false;
        }
        
        return dfs(root.left, low, root.val) 
           && dfs(root.right, root.val, up);
    }

SOLUTION 3:

同样是递归，但是把左右子树的min, max值返回，与当前的root值相比较。比较直观。

/*
        SOLUTION 3: Use the recursive version2.
    */
    public boolean isValidBST3(TreeNode root) {
        // Just use the inOrder traversal to solve the problem.
        if (root == null) {
            return true;
        }
        
        return dfs(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }
    
    public class ReturnType {
        int min;
        int max;
        boolean isBST;
        public ReturnType (int min, int max, boolean isBST) {
            this.min = min;
            this.max = max;
            this.isBST = isBST;
        }
    }
    
    // BST:
    // 1. Left tree is BST;
    // 2. Right tree is BST;
    // 3. root value is bigger than the max value of left tree and 
    // smaller than the min value of the right tree.
    public ReturnType dfs(TreeNode root) {
        ReturnType ret = new ReturnType(Integer.MAX_VALUE, Integer.MIN_VALUE, true);
        if (root == null) {
            return ret;
        }
        
        ReturnType left = dfs(root.left);
        ReturnType right = dfs(root.right);
        
        // determine the left tree and the right tree;
        if (!left.isBST || !right.isBST) {
            ret.isBST = false;
            return ret;
        }
        
        // 判断Root.left != null是有必要的，如果root.val是MAX 或是MIN value,判断会失误
        if (root.left != null && root.val <= left.max) {
            ret.isBST = false;
            return ret;
        }
        
        if (root.right != null && root.val >= right.min) {
            ret.isBST = false;
            return ret;
        }
        
        return new ReturnType(Math.min(root.val, left.min), Math.max(root.val, right.max), true);
    }

SOLUTION 4:

使用一个全局变量，用递归的中序遍历来做，也很简单（但全局变量主页君不推荐！）

/*
        SOLUTION 4: Use the recursive version3.
    */
    TreeNode pre = null;
    
    public boolean isValidBST(TreeNode root) {
        // Just use the inOrder traversal to solve the problem.
        return dfs4(root);
    }
    
    public boolean dfs4(TreeNode root) {
        if (root == null) {
            return true;
        }
        
        // Judge the left tree.
        if (!dfs4(root.left)) {
            return false;
        }
        
        // judge the sequence.
        if (pre != null && root.val <= pre.val) {
            return false;
        }
        pre = root;
        
        // Judge the right tree.
        if (!dfs4(root.right)) {
            return false;
        }
        
        return true;
    }

GITHUB:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/tree/IsValidBST_1221_2014.java