算法训练(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);
    }
};
相关推荐
JingHongB8 分钟前
代码随想录算法训练营Day55 | 图论理论基础、深度优先搜索理论基础、卡玛网 98.所有可达路径、797. 所有可能的路径、广度优先搜索理论基础
算法·深度优先·图论
weixin_4327022611 分钟前
代码随想录算法训练营第五十五天|图论理论基础
数据结构·python·算法·深度优先·图论
小冉在学习14 分钟前
day52 图论章节刷题Part04(110.字符串接龙、105.有向图的完全可达性、106.岛屿的周长 )
算法·深度优先·图论
Repeat71515 分钟前
图论基础--孤岛系列
算法·深度优先·广度优先·图论基础
小冉在学习17 分钟前
day53 图论章节刷题Part05(并查集理论基础、寻找存在的路径)
java·算法·图论
武子康29 分钟前
大数据-212 数据挖掘 机器学习理论 - 无监督学习算法 KMeans 基本原理 簇内误差平方和
大数据·人工智能·学习·算法·机器学习·数据挖掘
passer__jw7671 小时前
【LeetCode】【算法】283. 移动零
数据结构·算法·leetcode
Ocean☾1 小时前
前端基础-html-注册界面
前端·算法·html
顶呱呱程序1 小时前
2-143 基于matlab-GUI的脉冲响应不变法实现音频滤波功能
算法·matlab·音视频·matlab-gui·音频滤波·脉冲响应不变法
爱吃生蚝的于勒2 小时前
深入学习指针(5)!!!!!!!!!!!!!!!
c语言·开发语言·数据结构·学习·计算机网络·算法