Validate Binary Search Tree

https://oj.leetcode.com/problems/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.

解题思路：

这种题目也是面试也是比较爱问的，有数有递归。我们看这个递归的定义，一个树是BST，必须它的val比左子树所有的val都大，比右子树所有val都小，并且，他的左右子树也都是BST。

你看看，特别注意，是比左子树所有节点都大，比右子树所有的都小。递归的时候，不能光判断root.val > left.val就return true。否则下面的例子

                 5

              /       \

          1            9

                    /      \

                  3        10

实际他不是一个BST，因为3<5。但上面的方法判断不出。

我还是把这个想当然的写法写出来，警示自己。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean isValidBST(TreeNode root) {
        if(root == null){
            return true;
        }
        if(root.left != null){
            if(root.left.val >= root.val){
                return false;
            }
        }
        if(root.right != null){
            if(root.right.val <= root.val){
                return false;
            }
        }
        return isValidBST(root.left) && isValidBST(root.right);
    }
}

那一个brute force的方法，上面只比较root.left，那我遍历每个节点的时候，都取得他所有左子树节点的集合，与右子树节点的集合。也就是插入一个BFS或者DFS的算法，我这里用BFS，就可以了。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean isValidBST(TreeNode root) {
        if(root == null){
            return true;
        }
        if(root.left != null){
            List<TreeNode> leftNodeList = new ArrayList<TreeNode>();
            Queue<TreeNode> queue = new LinkedList<TreeNode>();
            queue.offer(root.left);
            while(queue.size() > 0){
                TreeNode temp = queue.poll();
                if(temp.left != null){
                    queue.offer(temp.left);
                }
                if(temp.right != null){
                    queue.offer(temp.right);
                }
                leftNodeList.add(temp);
            }
            for(TreeNode temp: leftNodeList){
                if(temp.val >= root.val){
                    return false;
                }
            }
        }
        if(root.right != null){
            List<TreeNode> rightNodeList = new ArrayList<TreeNode>();
            Queue<TreeNode> queue = new LinkedList<TreeNode>();
            queue.offer(root.right);
            while(queue.size() > 0){
                TreeNode temp = queue.poll();
                if(temp.left != null){
                    queue.offer(temp.left);
                }
                if(temp.right != null){
                    queue.offer(temp.right);
                }
                rightNodeList.add(temp);
            }
            for(TreeNode temp: rightNodeList){
                if(temp.val <= root.val){
                    return false;
                }
            }
        }
        return isValidBST(root.left) && isValidBST(root.right);
    }
}

这是一个AC的解法。但是用到了O(n)的空间，时间复杂度也上去了。下面考虑简化这个方法。

想象一个二叉树，当前节点必然比左子树的任何节点都大，也就是在左子树的所有节点中，该节点是最大的一个。反过来，在右子树所有节点中，该节点也是最小的一个。否则，这个数就不是BST。这也是一个递归的定义，那么我们可以把当前节点的val带进递归。代码如下。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean isValidBST(TreeNode root) {
        return validBST(root, Long.MAX_VALUE, Long.MIN_VALUE);
    }
    
    public boolean validBST(TreeNode root, long maxVal, long minVal){
        if(root == null){
            return true;
        }
        if(root.val >= maxVal){
            return false;
        }
        if(root.val <= minVal){
            return false;
        }
        return validBST(root.left, root.val, minVal) && validBST(root.right, maxVal, root.val);
    }
}

可以看到，这个方法比较简洁，理解后也比较简单。与上面的递归不同，这个方法不是比较root.left和root的值，已经root.right和root的值，是比较root的值与缓存下来的最大、最小值。这个缓存的值，是通过递归传下来的。每递归一个左子树，就用父节点去更新当前的最大值，递归右子树，更新最小值。

下面还有一个思路完全不同的解法。回忆 Binary Search Tree Iterator 这道题，如果一个数为BST，那么对他进行inorder的遍历，输出一定是一个排好序的数列。那么，这里我们就可以利用这个性质，一次性对这个数inorder遍历，将结果存在一个list里，然后从头往后判断，结果递增，就可以返回true。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean isValidBST(TreeNode root) {
        List<Integer> list = inOrderTravese(root);
        long temp = Long.MIN_VALUE;
        for(Integer i : list){
            if(i <= temp){
                return false;
            }
            temp = i;
        }
        return true;
    }
    
    public List<Integer> inOrderTravese(TreeNode root){
        List<Integer> list = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        
        while(root != null || stack.size() !=0){
            if(root != null){
                stack.push(root);
                root = root.left;
            }else{
                root = stack.pop();
                list.add(root.val);
                root = root.right;
            }
        }
        return list;
    }
}

总结一下，这道题一看便是一道递归的解法，但是要咬准递归的定义，还是需要了解一下的。特别是Integer.MIN_VALUE的边界，当然还有MAX_VALUE，我们可以初始化为Long.MIN_VALUE。第二种是一个很巧妙地解法，不straight-forward，但是一提出来就立刻可以理解了。他利用了BST的inorder遍历输出是一个排序数列的方法，用空间换时间，two-passs solution，巧妙地求解。