Leetcode-Validate BST

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

WRONG solution:

/**
 * 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;
        
        return isValidBSTRecur(root);
    }
    
    public boolean isValidBSTRecur(TreeNode curNode){
        if (curNode.left==null&&curNode.right==null)
            return true;
        
        boolean leftValid=true;
        boolean rightValid=true;
        
        if (curNode.left!=null){
            if (curNode.left.val>=curNode.val)
                return false;
            leftValid = isValidBSTRecur(curNode.left);
        }
        
        if (curNode.right!=null){
            if (curNode.right.val<=curNode.val)
                return false;
            rightValid = isValidBSTRecur(curNode.right);
        }
        
        if (leftValid&&rightValid)
            return true;
        else
            return false;
    }
}

This is wrong! Because we only consider about one level up! Example:

Input:	{10,5,15,#,#,6,20}
Output:	true
Expected:	false

Correct Solution:

/**
 * 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;
        
        List<Integer> queue = new ArrayList<Integer>();
        isValidBSTRecur(root,queue);
        
        for (int i=1;i<queue.size();i++)
            if (queue.get(i)<=queue.get(i-1))
                return false;
        
        return true;
    }
    
    public void isValidBSTRecur(TreeNode curNode, List<Integer> queue){
        if (curNode.left==null&&curNode.right==null){
            queue.add(curNode.val);
            return;
        }
            
        
        if (curNode.left!=null)
            isValidBSTRecur(curNode.left,queue);
        queue.add(curNode.val);
        if (curNode.right!=null)
            isValidBSTRecur(curNode.right,queue);
        
        return;
    }
}

We put nodes into a list in the preorder, then check whether the list is monotonic increasing.