leetcode #98 in cpp

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.

Solution:

At first I though it was a simple question: if the left and right subtrees are valid BST and root's number is bigger/smaller than the root of left/right subtree,then it is a valid BST. 

But this is wrong. 

Suppose we have a valid BST

    2   / \  1   3

and we make this as a subtree of a root 3

         3       /    2   / \  1   3

Even though [2,1,3] is a valid BST and the old root 2 < the new root 3, the new BST is not a valid BST. This is because the leaf node 3 is in the left subtree.

This tells us that the new root should be compared to all of its nodes in its subtree instead of only its left/right child. Thus my first though is wrong. 

But if we try to compare a node to all of nodes in its subtrees, the complexity is exponential. 

Lets make it in another way. 

Suppose we have a BST. 

     INT_MIN            5           INT_MAX       /             \     2                              9                    /       \    /         \  0      3  7        11               /              /      6            10     

If a BST is a valid BST, every node should fall in a range set by its precedents. Say 0 falls in [int_min, 2]. 2 falls in [int_min, 5]. 3 falls in [2,5]. 5 falls in [int_min, int_max]. 6 falls in [5,7]. 7 falls in [5,9]. 9 falls in [5, int_max]. 10 falls in [9,11]. 11 falls in [9, int_max]. 

If a BST is not a valid bST, there would be 1 node falling out of the range set by its precedents. The following is an invalid BST where 6(!) falls out of the range [2, 5].

 

          5          /                          \        2                            9                    /                        \     /         \  0            6(!) 7        11               /              /      6            10     

One node's range is set by its precedents, and this node's val would set the range for nodes in lower level of its subtree. 

Thus when we are at a node,

1. we check if this node is in its range [low, high]

2. If 1 is true, then we go check this node's left subtree, by setting the range for the left subtree [low, node->val-1]. After we check the leftsubtree we go check the right subtree, by setting the range for the right substree [node->val+1, high]. 

Code:

/** * 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 isValidBST(TreeNode* root) {        return validBST(root, INT_MIN, INT_MAX);    }    bool validBST(TreeNode *node, int lower, int higher){        if(!node) return true;        if(node->val == INT_MIN && node->left || node->val == INT_MAX && node->right) return false;        if(lower>higher || node->val < lower || node->val > higher) return false;                if(validBST(node->left, lower, node->val - 1) && validBST(node->right, node->val+1, higher)) return true;        else return false;    }};