检查是否为BST

题目描述

请实现一个函数，检查一棵二叉树是否为二叉查找树。

给定树的根结点指针TreeNode* root，请返回一个bool，代表该树是否为二叉查找树。

 

错在，二叉查找树是当前结点大于左子树的所有结点，不是只大于左子树的头节点。

错误解法：

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/

class Checker {
public:
    bool checkBST(TreeNode* root) {
        // write code here
        if(root == nullptr)
            return true;
        if(checkBST(root ->left) && checkBST(root ->right))
        {
            if(root ->left)
            {
                if(root ->val < root ->left ->val)
                    return false;
            }
            if(root ->right)
            {
                if(root ->val > root ->right ->val)
                    return false;
            }
        }
        return true;
    }
};

 

正确解法：

返回值为此树中最大的值。

用成员变量ans来判断是否合格，如果不合格就没必要再递归下去了。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/

class Checker {
public:
    bool ans = true;
    bool checkBST(TreeNode* root) {
        // write code here
        if(!root)
            return true;
        fun(root);
        return ans;
    }
    
    int fun(TreeNode* root)
    {
        if(!root ->left & !root ->right)
            return root ->val;
        if(!root ->left)
        {
            int right = fun(root ->right);
            if(root ->val > right)
            {
                ans = false;
            }
            return right > root ->val? right : root ->val;
        }
        if(!root ->right)
        {
            int left = fun(root ->left);
            if(root ->val < left)
            {
                ans = false;
            }
            return left > root ->val?  left : root ->val;
        }
        int left = fun(root ->left);
        if(!ans)
            return 0;
        int right = fun(root ->right);
        if(!ans)
            return 0;
        if(root ->val < left || root ->val > right)
        {
            ans = false;
            return 0;
        }
        int MAX = left > right ? left : right;
        return MAX > root ->val? MAX : root ->val;
    }
};