【leetcode】98. 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

Input: [2,1,3]
Output: true

Example 2:

    5
   / \
  1   4
     / \
    3   6

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

题目链接：https://leetcode.com/problems/validate-binary-search-tree/

 

诶这道题做的难受，思路又没想全面，好久不做题果然。。

解题思路

这道题也是明显的分治，BST的任意子树也是BST。但此题又不只有这一条限制，左子树所有节点都小于根节点，右子树所有节点都大于根节点，这是在注意组合子问题解的时都要点。解答可限制为：

1.根节点值大于左孩子，小于右孩子。

2.根节点值大于左子树最大值，大于右子树最小值。（根节点是左右子树的分界线）

其中2很容易被忽略。

代码一：递归

以上思路的实现也有技巧。

正常思路都是从顶向下递归进入子问题，再将子问题的解向上返回。

对于2个限制的实现，我的原思路是子问题在根节点上判断1，同时返回自己的值给上层判断2。这就很愚蠢了，为什么不能直接在分割子问题时，把父节点的信息传入子问题，作为子节点通过上下限判断自己是否正确？图样图乃易肤，树的二维结构迭代还是没想清楚。

/**
 * 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 isValidR(root, INT_MIN, INT_MAX);
    }
    bool isValidR(TreeNode* root, int lower_limit, int upper_limit) {
        if (!root) return true; 
        bool rootOK  =  root->val >= lower_limit && root->val <= upper_limit;
        bool rightOK = !root->right || ( root->val < INT_MAX && isValidR(root->right, root->val+1, upper_limit));
        bool leftOK  = !root->left  || ( root->val > INT_MIN && isValidR(root->left,  lower_limit, root->val-1));
        return rootOK && rightOK && leftOK;
    }
};

用c++写有几个坑：

1.c++中NULL是0的宏定义，因此在孩子节点判断自己是否符合上下界限制时，不能用!=NULL来初始化界限和判断是否有界。

以上写法会使界限0失效，不可取。

2.改用int的最大最小值作为初始界限时，不能使用>=和<=来作判断界限。

这样会使边界样例结果为false，如[2147483647]。

3.为了处理边界样例，不能直接将>=、<=改为>、<后在传递边界值是直接+1、-1.

这样可能出现 新上界=边界值上界+1，超出int范围报错。

-----

所以这里为了避开c++带来的坑，加了一段很有技巧的判断：

1.如果没有左孩子，直接返回true。

2.如果有左孩子，判断当前值是否是下届值，如果是，则肯定不可能有值更小的左孩子了，矛盾因此返回false；如果不是，那么正常进入递归。右孩子逻辑一样。

为这段判断的逻辑鼓掌?

代码二：非递归

非递归就是直接将递归方法翻译出来，比较繁琐，需要建立3个栈来储存回溯节点、上界、下界。实现参见题目的solution区。

代码三：非递归中序遍历

中序遍历BST的结果是增序排列好的数组，因此只要从最左下节点开始，判断上一个节点与下一节点的大小关系即可。

/**
 * 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) {
        stack<TreeNode*> camp;
        TreeNode* cur = root;
        int last = INT_MIN;
        while(cur!=NULL || !camp.empty()){
            while(cur!=NULL){
                camp.push(cur);
                cur = root->left;
            }
            cur = camp.top();
            camp.pop();
            if(cur->val<=last) return false;
            last = cur->val;
            cur = cur->right;
        }
    return true;
    }
};