二叉树 Leetcode 98 验证二叉搜索树

验证二叉搜索树

Leetcode 98
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

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

要点：1.需要识别出二叉搜索树是在中序遍历下是递增的；
2.节点左（右）子树下节点值都要小于（大于）当前节点值，不是局部满足；

学习记录自代码随想录
方法一：直接递归

class Solution {
public:
    long long max_value = LONG_MIN; // 最小值选择注意范围
    bool isValidBST(TreeNode* root) {
        
        if (root == nullptr) return true;

        bool left_tree = isValidBST(root->left);
        
        if (root->val > max_value) max_value = root->val;
        else return false;

        bool right_tree = isValidBST(root->right);

        return (left_tree && right_tree);        
    }
};

方法二：转化为数组后，检测数组是否递增

class Solution{
private:
    //中序遍历显示
    vector<int> vec;
    void traversal(TreeNode* root){
        if(root == nullptr) return;

        traversal(root->left);
        vec.push_back(root->val);
        traversal(root->right);
    } 
public:
    // 判断函数
    bool isValidBST(TreeNode* root){
        traversal(root);
        for(int i = 1; i < vec.size(); i++){ // 此处i从1开始
            if (vec[i] <= vec[i-1]){
                return false;
            }
        }
        return true;
    }
};

方法三：中序遍历迭代法（ACM模式）

#include <iostream>
#include <string>
#include <sstream>
#include <stack>
#include <vector>
#include <queue>

using namespace std;

struct TreeNode
{
    int val;
    TreeNode* left;
    TreeNode* right;

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

class Solution{
public:
    bool isValidBST(TreeNode* root){
        
        if(root->left == nullptr && root->right == nullptr) return true;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = nullptr;
        while(cur != nullptr || !st.empty()){
            if(cur != nullptr){
                st.push(cur);
                cur = cur->left;
            }else{
                cur = st.top();
                st.pop();

                if (pre != nullptr && cur->val <= pre->val) return false;
                pre = cur;

                cur = cur->right;   
            }
        }
        return true;
    }

    TreeNode* stringToTreeNode(string s){
        istringstream iss(s);
        string token;
        queue<TreeNode*> que;

        getline(iss, token, ',');
        if(token == "null") return nullptr;
        TreeNode* root = new TreeNode(stoi(token));

        que.push(root);
        while (!que.empty())
        {
            int len = que.size();
            for(int i = 0; i < len; i++){
                TreeNode* cur = que.front();
                que.pop();

                if(getline(iss, token, ',')){
                    if (token != "null"){
                        cur->left = new TreeNode(stoi(token));
                        que.push(cur->left);
                    }
                }

                if(getline(iss, token, ',')){
                    if (token != "null"){
                        cur->right = new TreeNode(stoi(token));
                        que.push(cur->right);
                    }
                }
            }
        }
        return root;
    }

    vector<int> TreeToResult_levelOrder(TreeNode* root){
        vector<int> result(0);
        if (root == nullptr) return result;

        queue<TreeNode*> que;
        que.push(root);

        while (!que.empty())
        {
            /* code */
            int len = que.size();
            for(int i = 0; i < len; i++){
                TreeNode* cur = que.front();
                result.push_back(cur->val);
                que.pop();
                
                if (cur->left == nullptr && cur->right == nullptr){
                    continue;
                }

                if(cur->left){
                    // result.push_back(cur->left->val);
                    que.push(cur->left);
                }
                else{
                    cur->left = new TreeNode(-10000);
                    que.push(cur->left);
                }
                
                if(cur->right){
                    // result.push_back(cur->right->val);
                    que.push(cur->right);
                }
                else{
                    cur->right = new TreeNode(-10000);
                    que.push(cur->right);
                }
                
            }
        }
        return result;
    }
};

int main(){
    Solution Solution;

    int n;
    while(cin >> n){
        string input;
        cin >> input;
        TreeNode* root = Solution.stringToTreeNode(input);
        bool result = Solution.isValidBST(root);
        cout << result;
    }
    return 0;
}

语法错误记录：
1.Line 1037: Char 34: runtime error: addition of unsigned offset to 0x502000000090 overflowed to 0x50200000008c (stl_vector.h)
SUMMARY: UndefinedBehaviorSanitizer: undefined-behavior /usr/bin/…/lib/gcc/x86_64-linux-gnu/11/…/…/…/…/include/c++/11/bits/stl_vector.h:1046:34

数组越界

2.vector vec();和vector vec;两者不同，可以是vector vec(10);