代码随想录算法训练营day20 | 654. 最大二叉树,617. 合并二叉树,700. 二叉搜索树中的搜索，98. 验证二叉搜索树

立夏满晴天

已于 2024-03-25 22:57:32 修改

阅读量188

点赞数 6

文章标签：算法数据结构

于 2024-03-25 22:55:43 首次发布

本文链接：https://blog.csdn.net/weixin_46536635/article/details/137024308

版权

654. 最大二叉树

文章链接：代码随想录 (programmercarl.com)

视频链接：又是构造二叉树，又有很多坑！| LeetCode：654.最大二叉树_哔哩哔哩_bilibili

笔记

新建节点new
i=begin
[)

C++代码

class Solution {
public:
    TreeNode* traversal(vector<int>& nums,int begin,int end){
        if(begin==end)return nullptr;
        TreeNode* root=new TreeNode(0);
        if(end-begin==1){
            root->val=nums[begin];
            return root;
        }
        int index=0;
        int max=INT_MIN;
        for(int i=begin;i<end;i++){
            if(max<nums[i]){
                max=nums[i];
                index=i;
            }
        }
        root->val=nums[index];
        root->left=traversal(nums,begin,index);
        root->right=traversal(nums,index+1,end);
        return root;


    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.size()==0)return nullptr;
        if(nums.size()==1){
            TreeNode* node=new TreeNode(0);
            node->val=nums[0];
            return node;
        }
        return traversal(nums,0,nums.size());
    }
};

617. 合并二叉树

文章链接：代码随想录 (programmercarl.com)

视频链接：一起操作两个二叉树？有点懵！| LeetCode：617.合并二叉树_哔哩哔哩_bilibili

笔记

很基础

C++代码

class Solution {
public:
    TreeNode* traversal(TreeNode* root1,TreeNode* root2){
        
        if(root1==nullptr && root2!=nullptr){
            return root2;
        }else if(root2==nullptr && root1!=nullptr){
            return root1;
        }else if(root1==nullptr && root2==nullptr){
            return nullptr;
        }
        TreeNode* rootNew=new TreeNode(0);
        rootNew->val=root1->val+root2->val;
        rootNew->left=traversal(root1->left,root2->left);
        rootNew->right=traversal(root1->right,root2->right);
        return rootNew;

    }
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(!root1 && !root2)return nullptr;
        return traversal(root1,root2);

    }
};

700. 二叉搜索树中的搜索

文章链接：代码随想录 (programmercarl.com)

视频链接：不愧是搜索树，这次搜索有方向了！| LeetCode：700.二叉搜索树中的搜索_哔哩哔哩_bilibili

笔记

没看到二叉搜索树

C++代码

递归

class Solution {
public:
    TreeNode* findVal(TreeNode* root,int val){
        if(root==nullptr)return nullptr;
        if(root->val==val)return root;
        TreeNode* res=nullptr;
        if(root->val>val){
            res=findVal(root->left,val);
        }else if(root->val<val){
            res=findVal(root->right,val);
        }
        return res;
    }
    TreeNode* searchBST(TreeNode* root, int val) {
        
        return findVal(root,val);
       
    }
};

迭代

class Solution {
public:
    
    TreeNode* searchBST(TreeNode* root, int val) {
        while(root!=nullptr){
            if(root->val<val){
                root=root->right;
            }else if(root->val>val){
                root=root->left;
            }else{
                return root;
            }
        }
        return nullptr;
       
    }
};

98. 验证二叉搜索树

文章链接：代码随想录 (programmercarl.com)

视频链接：你对二叉搜索树了解的还不够！ | LeetCode：98.验证二叉搜索树_哔哩哔哩_bilibili

笔记

不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了
二叉搜索树排序：中序递增
样例中最小节点可能是int的最小值，如果这样使用最小的int来比较也是不行的。

C++代码

递归

class Solution {
public:
    TreeNode* pre = NULL; // 用来记录前一个节点
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;
        bool left = isValidBST(root->left);

        if (pre != NULL && pre->val >= root->val) return false;
        pre = root; // 记录前一个节点

        bool right = isValidBST(root->right);
        return left && right;
    }
};

遍历

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = NULL; // 记录前一个节点
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) {
                st.push(cur);
                cur = cur->left;                // 左
            } else {
                cur = st.top();                 // 中
                st.pop();
                if (pre != NULL && cur->val <= pre->val)
                return false;
                pre = cur; //保存前一个访问的结点

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