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.

Method I

这道题应该在Recover Binary Search Tree之前做。

中序遍历，记得保存前一个节点。只要pre->val>=root->val就错了。

class Solution {
public:
    bool isValidBST(TreeNode *root) {
        pre = NULL;
        return inorder(root);
    }
    
    bool inorder(TreeNode *root) {
        if (!root) return true;
        if (!inorder(root->left)) return false;
        if (pre && pre->val >= root->val) return false;
        pre = root;
        return inorder(root->right);
    }
private:
    TreeNode* pre;
};

用Morris Traversal的方式竟然报runtime error。同样的代码可以跑在本机上，修改一下也可以通过Recover Binary Search Tree。真是奇怪。难道是leetccode上这道题不允许修改树本身。

class Solution {
public:
    bool isValidBST(TreeNode *root) {
        TreeNode* pre = NULL;
        TreeNode* current = root;
        
        while (current != NULL) {
            if (current->left == NULL) {
                if (pre != NULL && pre->val >= current->val) return false;
                pre = current;
                current = current->right;
            } else {
                TreeNode* rightmost = current->left;
                while (rightmost->right != NULL && rightmost->right != current) rightmost = rightmost->right;
                if (rightmost->right == NULL) {
                    rightmost->right = current;
                    current = current->left;
                } else {
                    rightmost->right = NULL;
                    if (pre != NULL && pre->val >= current->val) return false;
                    pre = current;
                    current = current->right;
                }
            }
        }
        return true;
    }
};

 Method II

参考自career cup chapter 4.

维护一个区间(min, max)，只要左子树、右子树都在一个正确的区间里就行了。

在检查左子树时，区间为(min, root->val)；

检查右子树时，区间为(root->val, max)；

注意是开区间。

/**
 * 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) {
        return recursive(root, INT_MIN, INT_MAX);
    }
    
    bool recursive(TreeNode *root, int min, int max) {
        if (root == NULL) return true;
        if (root->val <= min || root->val >= max) return false;
        return recursive(root->left, min, root->val) && recursive(root->right, root->val, max);
    }
};