LeetCode98 验证二叉搜索树

最讨厌写数据结构了。但是不得不写
这题意思就是确定一个二叉排序树合不合法，我保存了左子树和柚子树的最大最小值然后判断一下
五连wa哭了

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    long long min(long long a, long long b)
    {
        if(a<b) return a;
        return b;
    }
    long long max(long long a, long long b)
    {
        if(a>b) return a;
        return b;
    }
    bool judgeTree(TreeNode *root, long long *minVal, long long *maxVal)
    {
        //*minVal = 100000, *maxVal = -100000;
        long long leftMin = 10000000000, leftMax = -10000000000;
        long long rightMin = 10000000000, rightMax = -10000000000;
        if(!root) return true;
        if(!judgeTree(root->left, &leftMin, &leftMax)) return false;
        
        printf("curnum = %d
 curLEFTmin = %d
 curLEFTmax = %d
", root->val,leftMin,leftMax);
        if(!judgeTree(root->right, &rightMin, &rightMax)) return false;
        printf("curnum = %d
 curRmin = %d
 curRmax = %d
", root->val,rightMin,rightMax);
        if(root->left) 
        {
            *minVal = min(*minVal, leftMin);
            *maxVal = max(*maxVal, leftMax);
            if(leftMax>=root->val) return false;
        }
        if(root->right) 
        {
            *minVal = min(*minVal, rightMin);
            *maxVal = max(*maxVal, rightMax);
            if(rightMin<=root->val) return false;
        }
        *minVal = min(*minVal, root->val);
        *maxVal = max(*maxVal, root->val);
        printf("curnum = %d
 curmin = %d
 curmax = %d
", root->val,*minVal,*maxVal);
        return true;        
    }

    bool isValidBST(TreeNode* root) {
        long long minVal = 10000000000, maxVal = -10000000000;
        return judgeTree(root, &minVal, &maxVal);
    }
};

冰雨教的新解法
保存一个l和r
我的感觉就是 从下往上做约束很难 但是从上往下约束很容易

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
   bool judgeTree(TreeNode* root, long long l, long long r)
   {
       if(!root) return true;
       if(root->val<=l||root->val>=r) return false;
       return judgeTree(root->left, l, root->val)&&judgeTree(root->right, root->val, r);
   }
    bool isValidBST(TreeNode* root) {
        return judgeTree(root, -10000000000, 10000000000);
    }
};