檢查是否爲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;
    }
};