leetcode——第98题——验证二叉搜索树

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

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

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

用了四种写法，奥利给~

/**
 * 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 {
// /********************法一：：递归+数组判断*************************/
// private:
//     void travel(TreeNode* cur, vector<int>& res)
//     {
//         if(cur == nullptr)
//         {
//             return;
//         }
//         travel(cur->left, res);
//         res.push_back(cur->val);
//         travel(cur->right, res);
//         // 这里的return是没有必要写的 看primer的199页
//         // void 类型的函数可以没有 return 语句，但是main 函数除外
//         return;
//     }
// public:
//     bool isValidBST(TreeNode* root) 
//     {
           // 注意这个res 也可以不在主函数中定义，把它定义为一个 private的成员变量
//         vector<int> res;
//         travel(root,res);
//         // 这里终止条件写错了，i<res.size()-1，没有减一，要注意哦 ~
//         for(int i=0; i<res.size()-1; i++)
//         {
//             if(res[i] >= res[i+1])
//             {
//                 return false;
//             }
//         }
//         return true;
//     }

// /********************法二：：递归判断***LONG_MIN**********************/
// private:
// // 因为需要比较遍历的节点是否有序，所以定义一个全局变量
// // 又因为后台测试数据有 int 最小值，将其初始化为long long 最小值
// // 第一次写 long long 注意中间是有一个空格的
//     long long maxVal = LONG_MIN;
// public:
// // 本题在递归的过程中，遍历每一个节点，为的是找到一个不符合条件的，如果有立即返回false
// // 如果最后仍没有，那么就返回 true
// // 采用的是递归中序遍历     左 中 右
//     bool isValidBST(TreeNode* root) 
//     {
//         // 终止条件：如果节点为空，返回true
//         if(root == nullptr)
//         {
//             return true;
//         }

//         // 单层递归逻辑
//         // 左
//         bool left = isValidBST(root->left); 

//         // 中
//         if(maxVal < root->val)
//         {
//             // 更新 最小值
//             maxVal = root->val;
//         }
//         else
//         {
//             return false;
//         }

//         // 右
//         bool right = isValidBST(root->right);

//         return left && right ;

//     }

// /********************法二升级版：：递归判断**********************/
// public:
//     // 这里的比较对象 把定义的 LONG_MIN 换为前一个指针
//     TreeNode* pre = nullptr;
//     bool isValidBST(TreeNode* root)
//     {
//         if(root == nullptr)     return true;
//         bool left = isValidBST(root->left);
//         // 注意这里的判断条件，
//         // 1、要为非空指针
//         // 2、相等的时候也属于 false 的情况
//         if(pre != nullptr && pre->val >= root->val)    return false;
//         else    pre = root;
//         bool right = isValidBST(root->right);

//         return left && right;
//     }

/********************法三：：迭代判断*************************/
public:
    bool isValidBST(TreeNode* root) 
    {
        stack<TreeNode*> st;
        if(root == nullptr) return true;
        st.push(root);
        TreeNode* pre = nullptr;
        // 啊啊啊啊这里竟然忘记取反了，真是什么错误都会犯，奇葩大王~~~
        while(!st.empty())
        {
            TreeNode* node = st.top();
            if(node != nullptr)
            {
                // 入栈的时候注意 空节点不入栈，所以要判断非空。只有标记空节点
                st.pop();
                if(node->right != nullptr)  st.push(node->right);
                st.push(node);
                st.push(nullptr);
                if(node->left != nullptr)   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;
    }
};