Leetcode——98验证二叉搜索树

题目描述：
给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

思路： 二叉搜索树的中序遍历的结果的递增的。
解法1： 递归+创建数组

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
//二叉搜索树的中序遍历的结果是递增的

class Solution {
public:
    void inorder(TreeNode* root, vector<int>& res) {
        if (root == nullptr) return;
        inorder(root->left, res);
        res.push_back(root->val);
        inorder(root->right, res);
    }
    bool isValidBST(TreeNode* root) {
        vector<int> res;
        inorder(root, res);
        for (int i = 0; i < res.size() - 1; i++) {
            if (res[i] >= res[i + 1]) return false;
        }
        return true;
    }
};

解法2： 递归+依次比较大小

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* pre = nullptr;
    bool isValidBST(TreeNode* root) {
        if (root == nullptr) return true;
        bool leftVali = isValidBST(root->left); //验证左子树
        if (pre!= nullptr && pre->val >= root->val) return false;
        pre = root;
        bool rightVali = isValidBST(root->right); //验证右子树
        return leftVali & rightVali;
    }
};

解法3： 迭代法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        //迭代，中序遍历
        TreeNode* pre = nullptr;
        stack<TreeNode*> st;
        if (root) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node) {
                st.pop();
                if (node->right) st.push(node->right);
                st.push(node);
                st.push(nullptr);
                if (node->left) st.push(node->left);  
            }
            else {
                st.pop();
                node = st.top();
                st.pop();
                if (pre != nullptr && pre->val >= node->val) return false;
                pre = node;
            }
        }
        return true;
    }
};

总结： 本题在于抓住关键因素——二叉搜索树的中序遍历的结果的递增的，利用改特性对结果进行递增性判断即可。