算法训练(leetcode)第十五天 | 654. 最大二叉树、617. 合并二叉树、700. 二叉搜索树中的搜索、98. 验证二叉搜索树

刷题记录

654. 最大二叉树

leetcode题目地址

本题和106. 从中序与后序遍历序列构造二叉树思路类似,递归建树,每次找出最大值赋值给当前节点,接着递归左子树和右子树。

时间复杂度: O ( n ) O(n) O(n)
空间复杂度: O ( n ) O(n) O(n)

cpp 复制代码
// c++
/**
 * 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* createTree(vector<int>& nums, int left, int right){
        if(left>right) return NULL;
        // 记录最大值下标
        int max_idx = left;
        int idx = left;
        // 找最大
        for(; idx<=right; idx++){
            if(nums[idx] > nums[max_idx]) {
                max_idx = idx;
            }
        }
        // 用最大值创建节点
        TreeNode* root = new TreeNode(nums[max_idx]);
        // 递归左右子树
        root->left = createTree(nums, left, max_idx-1);
        root->right = createTree(nums, max_idx+1, right);
        return root;
    }
    
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode* root = createTree(nums, 0, nums.size()-1);
        return root;
    }
};

617. 合并二叉树

leetcode题目地址

上题思路类似,只不过是同时遍历两个树,题目新颖,第一次遇到。

时间复杂度: O ( n ) O(n) O(n)
空间复杂度: O ( n ) O(n) O(n)

cpp 复制代码
// c++
/**
 * 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* Order(TreeNode* root1, TreeNode* root2){
        if(!root1 && !root2) return nullptr;
        TreeNode* root;
        if(root1 && root2){
            root = new TreeNode(root1->val + root2->val);
            root->left = Order(root1->left, root2->left);
            root->right = Order(root1->right, root2->right);
            
        }else if(!root1){
            root = new TreeNode(root2->val);
            root->left = Order(nullptr, root2->left);
            root->right = Order(nullptr, root2->right);
        }else{
            root = new TreeNode(root1->val);
            root->left = Order(root1->left, nullptr);
            root->right = Order(root1->right, nullptr);
        }
        return root;
    }
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        // TreeNode root;
        return Order(root1, root2);
    }
};

700. 二叉搜索树中的搜索

leetcode题目地址

借助前序遍历来查找,找到则返回该节点。

时间复杂度: O ( n ) O(n) O(n)
空间复杂度: O ( n ) O(n) O(n)

直接前序遍历

cpp 复制代码
// c++
/**
 * 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 preOrder(TreeNode* root, int val, TreeNode* &result){
        if(!root) return;
        if(root->val == val){
            result = root;
            return;
        }
        // 没找到时递归左右子树,找到了就停止
        if(!result)
            preOrder(root->left, val, result);
        if(!result)
            preOrder(root->right, val, result);
        
    }
    TreeNode* searchBST(TreeNode* root, int val) {
        TreeNode* result = nullptr;
        preOrder(root, val, result);
        return result;
    }
};

借助BST性质

借助BST左小右大的性质来提高查找效率。(其实就是改一个递归左右子树的判断)

cpp 复制代码
// c++
/**
 * 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 preOrder(TreeNode* root, int val, TreeNode* &result){
        if(!root) return;
        if(root->val == val){
            result = root;
            return;
        }
        // 没找到时递归左右子树,找到了就停止
        if(root->val > val)
            preOrder(root->left, val, result);
        if(root->val < val)
            preOrder(root->right, val, result);
        
    }
    TreeNode* searchBST(TreeNode* root, int val) {
        TreeNode* result = nullptr;
        preOrder(root, val, result);
        return result;
    }
};

98. 验证二叉搜索树

leetcode题目地址

与上题类似,这里使用中序遍历。BST的中序遍历结果是一个单调递增序列,因此在遍历时出现递减(或相等)则不是BST。

时间复杂度: O ( n ) O(n) O(n)
空间复杂度: O ( n ) O(n) O(n)

中规中矩版

cpp 复制代码
// c++
/**
 * 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, bool & result, TreeNode* &last){
        if(!root) return ;
        inOrder(root->left, result, last);
        if(last && last->val >= root->val) {
            result = false;
            return;
        }
        last = root;
        inOrder(root->right, result, last);
    }
    bool isValidBST(TreeNode* root) {
        bool result = true;
        TreeNode* last = nullptr;
        inOrder(root, result, last);
        return result;
    }
};

简洁版:

简化了一下参数传递,改成函数值返回。

cpp 复制代码
// c++
/**
 * 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 inOrder(TreeNode* root,  TreeNode* &last){
        if(!root) return true;
        bool left = inOrder(root->left, last);
        if(last && last->val >= root->val) {
            return false;
        }
        last = root;
        bool right = inOrder(root->right, last);
        return left && right;
    }
    bool isValidBST(TreeNode* root) {
        TreeNode* last = nullptr;
        return inOrder(root, last);
    }
};
相关推荐
yyt_cdeyyds1 分钟前
FIFO和LRU算法实现操作系统中主存管理
算法
暮色_年华3 分钟前
Modern Effective C++item 9:优先考虑别名声明而非typedef
c++
重生之我是数学王子11 分钟前
QT基础 编码问题 定时器 事件 绘图事件 keyPressEvent QT5.12.3环境 C++实现
开发语言·c++·qt
alphaTao28 分钟前
LeetCode 每日一题 2024/11/18-2024/11/24
算法·leetcode
我们的五年35 分钟前
【Linux课程学习】:进程程序替换,execl,execv,execlp,execvp,execve,execle,execvpe函数
linux·c++·学习
kitesxian37 分钟前
Leetcode448. 找到所有数组中消失的数字(HOT100)+Leetcode139. 单词拆分(HOT100)
数据结构·算法·leetcode
做人不要太理性1 小时前
【C++】深入哈希表核心:从改造到封装,解锁 unordered_set 与 unordered_map 的终极奥义!
c++·哈希算法·散列表·unordered_map·unordered_set
程序员-King.1 小时前
2、桥接模式
c++·桥接模式
chnming19871 小时前
STL关联式容器之map
开发语言·c++
VertexGeek1 小时前
Rust学习(八):异常处理和宏编程:
学习·算法·rust