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