98. Validate Binary Search Tree

• 方法1: recursion
• • 易錯點
• 方法2: iterative (inorder)

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:

Input:
    2
   / \
  1   3
Output: true
           

Example 2:

5
   / \
  1   4
     / \
    3   6
Output: false
Explanation: The input is: [5,1,4,null,null,3,6]. The root node's value
             is 5 but its right child's value is 4.
           

方法1: recursion

易錯點

1. 如果不用long會hold不住一些test case
2. 用 lb 和 ub 已經可以包括left < root < right 之間的關系了，不用再追加check

/**
 * 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 validHelper(root, LONG_MIN, LONG_MAX);
    }
    
    bool validHelper(TreeNode* root, long lb, long ub) {
        if(!root) return true;
        if (root -> val <= lb || ub <= root -> val) return false;
        return (validHelper(root -> left, lb, root -> val) && validHelper(root -> right, root -> val, ub));
    }
};
           

方法2: iterative (inorder)

用inorder traversal來周遊，每次記住上一次pop出來的數字，必須嚴格遞增。

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> myStack;
        
        if (root == NULL){
            return true;
        }
        
        myStack.push(root);
        root = root->left;
        long current = LONG_MIN;
        
        while(!myStack.empty()||root != NULL){
            
            if (root != NULL){
                myStack.push(root);
                root = root->left;
            } else {
                if (current < myStack.top() -> val){    
                    current = myStack.top() ->val;
                    result.push_back(current);
                } else { 
                    return false;
                }
                
                root = myStack.top()->right;
                myStack.pop();
            }
        }
     
     return true;       
    }
};