LeetCode | 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.
Example 1:
2
/ \
1 3
Binary tree [2,1,3], return true.
Example 2:
1
/ \
2 3
Binary tree [1,2,3], return false.

---

这道题新加的用例…无语….
这样只能用中序遍历到数组里面然后求解了..

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if(!root) return true;
        // if(!root->left && !root->right) return true;
        // if(root->left && root->left->val >= root->val) return false;
        // if(root->right && root->right->val <= root->val) return false;

        return validBST(root,INT_MIN,INT_MAX);
    }

    bool validBST(TreeNode* root,int start,int end){
        if(!root) return true;

        // //说明这两个数据由前两层而来
        // if(root->val == INT_MIN){
        //     if(root->left!=NULL) return false;
        //     // if(root->right && root->right->val <= INT_MIN) return false;
        //     if(!root->left && !root->right) return true;
        // }
        // if(root->val == INT_MAX){
        //     if(root->right) return false;
        //     // if(root->left && root->left->val >= INT_MAX ) return false;
        //     if(!root->left && !root->right) return true;
        // }
        // //

        // //最重要的错误在这里，这个条件不能保证是false
        // // //每个节点下降的时候都应当是有一个区间限制的
        if((root->val <= start || root->val >=end)
        // // || (root->val==INT_MAX && !root->right) || (root->val==INT_MIN && !root->left)
        ) return false;

        // // //它的左右子树也会被受到限制，但我们选择将这一步归纳为每一个节点应当处理的
        // // if(root->left && root->left->val >= root->val) return false;
        // // if(root->right && root->right->val <= root->val) return false;

        bool left=true,right=true;
        if(root->left)
        left=validBST(root->left,start,root->val);
        if(root->right)
        right=validBST(root->right,root->val,end);

        return left && right;
        // return ( (root->val > start && root->val < end && validBST(root->left,start,root->val) && validBST(root->right,root->val,end))
        // || (root->val==INT_MIN && !root->left && (!isEdge(start,end) && root->val<end) && ((root->right && root->right->val > root->val ) || !root->right ) && validBST(root->right,root->val,end))
        // || (root->val==INT_MAX && !root->right && (!isEdge(start,end) && root->val>start) && ((root->left && root->left->val < root->val ) || !root->left ) && validBST(root->left,start,root->val))
        // );
    }
};

解决的办法是中序遍历到数组里面…

---

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        vector<int> result;
        if(!root) return true;

        //中序遍历
        TreeNode* temp=root;
        stack<TreeNode*> Q;
        while(temp || !Q.empty()){
            if(temp){
                Q.push(temp);
                temp=temp->left;
            }
            else{
                temp=Q.top();
                Q.pop();
                result.push_back(temp->val);
                temp=temp->right;
            }
        }

        //得到递增序列
        int n=result.size();
        if(n==1) return true;
        for(int i=1;i<n;i++){
            if(result[i]<=result[i-1]) return false;
        }
        return true;
    }
};

其实也可以不用数组，因为只是为了判断一个递增的趋势而已

    int prev=INT_MIN,count=0;
    stack<TreeNode*> Q;
    while(root || !Q.empty()){
        if(root){
            Q.push(root);
            root=root->left;
        }
        else{
            root=Q.top();
            Q.pop();
            //是否为第一次读入数据
            if(!count++){
                prev=root->val;
            }
            else{
                if(root->val <= prev) return false;
                prev=root->val;
            }
            root=root->right;
        }
    }
    return true;