Leetcode98.验证二叉搜索树（中等）C++ 数组 递归 迭代

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

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

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

输入:
2
/
1 3
输出: true
示例 2:

输入:
5
/
1 4
/
3 6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
根节点的值为 5 ，但是其右子节点值为 4 。
--------------旧的题解------------------
思路描述：
首先一定要明确什么是二叉搜索树，根节点一定比左子树的任意节点值大，一定比右子树的任意节点值小。
根节点和子树的关系是在每一个子树中有存在的，所以我们很容易想到用递归，或者说，树的问题没有特殊的性能要求都会想到递归；
简单的思路就是，对每个节点的左右孩子进行判断，如果不满足bst树的要求则返回false。但是这里有个问题就是，只是比较了当前节点的左右孩子，而不是左右子树，但是目前的递归函数接口并没有给我们传递多余参数的地方，很自然的想到用辅助函数来传递左右子树的最大最小值，进而保证子树的BST树性质。

代码：

/**
 * 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) {
        return isValidBST_withRoot(root, NULL, NULL);
    }
    // 因为判断是否
    bool isValidBST_withRoot(TreeNode* root, TreeNode* min ,TreeNode* max){ // min和max维护的是每次循环中子树的最小和最大值
        if(root == NULL) return true; // 空树返回true
        if(min != NULL && root->val <= min->val) return false; // 子树中出现了左子树的节点值小于了最小的父类节点，不满足二叉树，返回false
        if(max != NULL && root->val >= max->val) return false; // 子树中出现了左子树的节点值大于了最大的父类节点，不满足二叉树，返回false
        return isValidBST_withRoot(root->left, min, root) && isValidBST_withRoot(root->right, root, max); // 递归，并更新min和max
    }
};

-----------------------新思路题解---------------------------
思路一

// 把二叉搜索树转变成 数组是最直观的一种思路
// 中序遍历后即为一个有序数组，之后遍历一遍数组即可知道是否满足二叉搜索树

class Solution {
private:
    void is_BST(TreeNode* root){
        if(root == nullptr) return;
        
        is_BST(root->left);
        
        if(result.empty()){
            first = root->val;
        }
        result.push_back(root->val);
        is_BST(root->right);
    }
    bool is_order(vector<int> &result){
        for(int i=1; i<result.size(); ++i){
            if(first >= result[i]) // 有相等元素也不是二叉搜索树
                return false;
            else 
                first = result[i];
        }
        return true;
    }
vector<int> result;
int first;

public:
    bool isValidBST(TreeNode* root) {
        if(root == nullptr) return true;
        is_BST(root);
        return is_order(result);
    }
};

思路二

// 也可以不将二叉搜索树转变为数组，可以在遍历的过程中直接进行判断，思路还是不变
class Solution {
public:
    //int max = INT_MIN; // 此时有个别的测试通不过，是因为测试用例中有最小的int值，
    // 能AC的修改
    //long long max = LONG_MIN; // 考虑使用 long long 类型的最小值最为 开始的比较元素
    
    // 当然，如果测试中使用的测试用例变得更小了呢，我们其实可以考虑将树的最左边的子节点赋值给max，可以应对所有的测试用例
    TreeNode* max = nullptr;

    bool isValidBST(TreeNode* root) {
        if(root == nullptr) return true; // 空树是 二叉搜索树，返回true
        bool left = isValidBST(root->left);
        
        if(max != nullptr && max->val >= root->val) // 保证max 能初始话为树的最左节点
            return false;
        max = root;

        bool right = isValidBST(root->right);

        return left && right;

    }
};

思路三

// 当然还是可以使用迭代法 来中序遍历二叉搜索树进而进行判断的
// 同样也可以用迭代法进行 中序遍历， 遍历过程中进行比较即可
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if(root == nullptr) return true;
        TreeNode* cur = root;
        TreeNode* pre = nullptr; // 记录前一个节点
        stack<TreeNode*> stk;
        while(!stk.empty() || cur != nullptr){ // 中序遍历的循环条件， 为 或
            if(cur != nullptr){
                stk.push(cur);
                cur = cur->left;
            }
            else{
                cur = stk.top();
                stk.pop();
                if(pre != nullptr && pre->val >= cur->val) 
                    return false;
                pre = cur; // 记录上一个节点
                cur = cur->right;
            }
        }
        return true;
    }
};