leetcode[98] Validate Binary Search Tree

判断给定的数是不是合法的BST。即当前节点值比他左子树大，比右子树小。

思路一：递归，考虑所有可能。

1. 为空是返回true

2. 用flag记录左子树返回的合法性。考虑左子树不空的时候，那么要根要比左子树的最右下角要大。

3. flag为真且右子树也为真则返回真。考虑右子树时，根要比右子树的最左小。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode *root) 
    {
        if (!root) return true;
        bool flag = true;
        if (root -> left != NULL)
        {
            if (root -> left -> right == NULL)
            {
                if (root -> val > root -> left -> val)
                    flag = isValidBST(root -> left);
                else
                    return false;
            }
            else
            {
                TreeNode *lr = root -> left -> right;
                while(lr -> right) lr = lr -> right;
                if (root -> val > root -> left -> val && root -> val > lr -> val)
                    flag = isValidBST(root -> left);
                else
                    return false;
            }
        }
        if (root -> right != NULL)
        {
            if (root -> right -> left == NULL)
            {
                if (root -> val < root -> right -> val)
                    return flag && isValidBST(root -> right);
                else
                    return false;
            }
            else
            {
                TreeNode *rl = root -> right -> left;
                while(rl -> left) rl = rl -> left;
                if (root -> val < root -> right -> val && root -> val < rl -> val)
                    return flag && isValidBST(root -> right);
                else
                    return false;
            }
        }
        return flag;
    }
};

虽然AC了，写了那么长自己都觉得。。。

然后网上看了说可以设定上下限制

/**
 * 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 isBSTRec(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
    }
    
    public boolean isBSTRec(TreeNode root, int left, int right) {
        if(root == null) {
            return true;
        }
        if(root.val <= left || root.val >= right) {
            return false;
        }
        
        return isBSTRec(root.left, left, root.val) && isBSTRec(root.right, root.val, right);
    }
}

思路是根据一棵树的根为a，右子树为b，那么右子树的左儿子c的值一定是大于a且小于b

但如果树的值就是最大值的时候似乎bug。确实是。临界值不行。

不过还是找到一个写的比较简单的递归：

public class Solution {
    public boolean isValidBST(TreeNode root) {
        if(root == null){
            return true;
        }
        return isSubTreeLessThan(root.left, root.val) && isSubTreeGreaterThan(root.right, root.val) && isValidBST(root.left) && isValidBST(root.right);
    }
    
    public boolean isSubTreeLessThan(TreeNode node, int val){
        if(node == null){
            return true;
        }
        return node.val < val && isSubTreeLessThan(node.left, val) && isSubTreeLessThan(node.right, val);
    }
    
    public boolean isSubTreeGreaterThan(TreeNode node, int val){
        if(node == null){
            return true;
        }
        return node.val > val && isSubTreeGreaterThan(node.left, val) && isSubTreeGreaterThan(node.right, val);
    }
    
    
}

还有一种方法是利用中序遍历得到数组，然后判断数组是不是递增的就行。用到n的空间。

很多个地方都说min和max那个可行，估计是之前的leetcode的case没有考虑到最大值。现在已经过不了了。