代码随想录算法训练营第十八天| 513.找树左下角的值 112. 路径总和 113.路径总和ii 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树

最新推荐文章于 2024-10-01 23:05:47 发布
最新推荐文章于 2024-10-01 23:05:47 发布
阅读量46 收藏
点赞数
分类专栏： 代码随想录训练营 文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hireath_/article/details/130702055
版权

文章目录

513.找树左下角的值

思路

首先自己的想法是层序遍历
但还是跟着敲了一遍递归

代码

递归

class Solution {
public:
    int maxDepth = INT_MIN;
    int result;
    void travelsal(TreeNode* root, int depth) {
        if(root->left == NULL && root->right == NULL) {
            if(depth > maxDepth) {
                maxDepth = depth;
                result = root->val;
            }
            return;
        }

        if(root->left) {
            depth++;
            travelsal(root->left,depth);
            depth--;
        }
        if(root->right) {
            depth++;
            travelsal(root->right,depth);
            depth--;
        }
        return;
    }
    int findBottomLeftValue(TreeNode* root) {
        travelsal(root,0);
        return result;
    }
};

层序遍历

class Solution {
public:
    
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        int result = 0;
        while(!que.empty()) {
            int size = que.size();
            for(int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if(i == 0) result = node->val;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return result;
    }
};

总结

112. 路径总和

思路

  1. 递归函数什么时候需要返回值？什么时候不需要返回值？这里总结如下三点：
    a. 如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。（这种情况就是本文下半部分介绍的113.路径总和ii）
    b. 如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。 （这种情况我们在236. 二叉树的最近公共祖先
    c. 如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。（本题的情况）

  2. 累加变累减：不要去累加然后判断是否等于目标和，那么代码比较麻烦，可以用递减，让计数器count初始为目标和，然后每次减去遍历路径节点上的数值。
    如果最后count == 0，同时到了叶子节点的话，说明找到了目标和。

  3. 因为终止条件是判断叶子节点，所以递归的过程中就不要让空节点进入递归了。

  4. 迭代法有点复杂

代码

class Solution {
public:
    bool travelsal(TreeNode* cur, int count) {
        if(!cur->left && !cur->right && count == 0) return true;
        if(!cur->left && !cur->right) return false;

        if(cur->left) {
            if(travelsal(cur->left,count- cur->left->val)) return true;
        }
        if(cur->right) {
            // 注意回溯逻辑
            if(travelsal(cur->right,count- cur->right->val)) return true;
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == NULL) return false;
        return travelsal(root,targetSum - root->val);
    }
};

迭代

class Solution {
public:
    
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == NULL) return false;

        stack<pair<TreeNode*, int>> st;

        st.push(pair<TreeNode*,int>(root,root->val));
        while (!st.empty())
        {
            pair<TreeNode*,int> node = st.top();
            st.pop();

            if(!node.first->left && !node.first->right && targetSum == node.second) return true;

            if(node.first->right) {
                st.push(pair<TreeNode*,int> (node.first->right,node.second + node.first->right->val));

            }

            if(node.first->left) {
                st.push(pair<TreeNode*,int> (node.first->left,node.second + node.first->left->val));

            }

        }
        return false;
    }
};

总结

  1. 注意回溯逻辑：travelsal(cur->left,count- cur->left->val)这里包含的意思是把减掉数字的count的值传进去，但是等他回溯到上一层节点时，count是没变的，做到的了回溯。也可以手动先减后加完成回溯逻辑

113.路径总和ii

思路

和上一题不同，上一题是要找是否存在一条路径，这题要搜索整个树，找到所有结果

代码

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void travelsal(TreeNode* cur, int count) {
        if(!cur->left && !cur->right && count == 0) {
            result.push_back(path);
            return;
        }
        if(!cur->left && !cur->right) return;

        if(cur->left) {
            path.push_back(cur->left->val);
            count -= cur->left->val;
            travelsal(cur->left,count);
            count += cur->left->val;
            path.pop_back();
        }

        if(cur->right) {
            path.push_back(cur->right->val);
            count -= cur->right->val;
            travelsal(cur->right,count);
            count += cur->right->val;
            path.pop_back();
        }
        return;
    }
public:
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        result.clear();
        path.clear();

        if(root == NULL ) return result;
        path.push_back(root->val);
        travelsal(root, targetSum - root->val);
        return result;
    }
};

总结

  1. ”如果需要搜索整颗二叉树，那么递归函数就不要返回值，如果要搜索其中一条符合条件的路径，递归函数就需要返回值，因为遇到符合条件的路径了就要及时返回。“ （ref:二叉树：递归函数什么时候需要返回值？）

106.从中序与后序遍历序列构造二叉树

思路

此时有一个很重的点，就是中序数组大小一定是和后序. 数组的大小相同的（这是必然）。

  1. 第一步：如果数组大小为零的话，说明是空节点了。
  2. 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
  3. 第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
  4. 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）
  5. 第五步：切割后序数组，切成后序左数组和后序右数组
  6. 第六步：递归处理左区间和右区间

代码

class Solution {
private:
    TreeNode* travelsal(vector<int>& inorder, vector<int>& postorder) {
        if(postorder.size() == 0) return NULL;

        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);

        if(postorder.size() == 1) return root;

        int delimiterIndex;
        for(delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
            if(inorder[delimiterIndex] == rootValue) break;
        }

        // 左闭右开
        vector<int> leftInorder(inorder.begin(), inorder.begin()+delimiterIndex);
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end());

        postorder.resize(postorder.size() -1);

        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        root->left = travelsal(leftInorder, leftPostorder);
        root->right = travelsal(rightInorder, rightPostorder);

        return root;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size() == 0 || postorder.size() == 0) return NULL;

        return travelsal(inorder,postorder);
    }
};

总结

  1. 用下标索引效率会更好
  2. 注意左闭右开，循环不变量

105.从前序与中序遍历序列构造二叉树

思路

和后序思路一样

代码

class Solution {
private:
    TreeNode* travelsal(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0) return NULL;

        int rootValue = preorder[0];
        TreeNode* root = new TreeNode(rootValue);

        int delimiterIdx;
        for (delimiterIdx = 0; delimiterIdx < inorder.size(); delimiterIdx++) {
            if(inorder[delimiterIdx] == rootValue) {
                // 均无重复元素才可以这样做
                break;
            }
        }

        // 左闭右开
        // [0,delimiterIdx)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIdx);
        // [delimiterIdx+1,end)
        vector<int> rightInorder(inorder.begin() + delimiterIdx + 1, inorder.end());
        // [1,)
        vector<int> leftPreorder(preorder.begin()+1, preorder.begin() + 1 + leftInorder.size());
        vector<int> rightPreorder(preorder.begin() + 1 + leftInorder.size(), preorder.end() );

        root->left = travelsal(leftPreorder, leftInorder);
        root->right = travelsal(rightPreorder, rightInorder);

        return root;
    }
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0 || inorder.size() == 0) return NULL;
        return travelsal(preorder,inorder);
    }
};

总结

  1. 这种方法因为每一层都new了vector所以不如索引方法好，但是思路很清楚
MoonBlue:)
关注
专栏目录
代码随想录算法训练营第一天 - 704. 二分查找
05-08
代码随想录算法训练营第一天 - 704. 二分查找
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
10-12
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
8.《代码随想录》回溯算法（V3.0）.pdf
07-21
《代码随想录》回溯算法（V3.0）解析 #### 回溯算法理论基础 **回溯算法概述** 回溯算法是一种通过尝试解决某个问题所有可能解的方法，来找到所有可行解或最优解的算法策略。这种算法常用于解决约束满足问题、...
二叉树最小深度
2301_80161204的博客
09-27 461
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1272
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
904. 水果成篮
YQ20210216的博客
09-27 358
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 759
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
排序算法之归并排序
最新发布
qq_64039411的博客
10-01 223
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
python 实现linear discriminant analysis线性判别分析算法
luthane的博客
09-26 518
线性判别分析（Linear Discriminant Analysis，简称LDA）是一种用于降维和分类的监督学习算法。它通过最大化类间散度和最小化类内散度来找到最佳投影方向，使得不同类别的数据在新的空间中尽可能分开，同一类别的数据尽可能靠近。LDA的基本思想LDA的基本思想是将多维数据映射到低维空间，同时保留数据之间的类别差异。具体来说，LDA通过计算类内散度矩阵（描述同一类别内部数据的分布情况）和类间散度矩阵（描述不同类别之间的差异），然后求解这两个矩阵的广义特征值问题，找到最佳的投影方向。
代码随想录算法训练营day46
qq_56445436的博客
10-01 117
【代码】代码随想录算法训练营day46。
35.搜索插入位置
m0_59860403的博客
10-01 75
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为O(log n)的算法。214。
opencv实战项目二十八：基于Shi-Tomasi算法的箱子角点检测
HanWenKing的博客
09-27 1471
随着科技的飞速发展，计算机视觉技术在我们的日常生活中扮演着越来越重要的角色。从无人驾驶汽车到智能手机的摄像头，再到各种智能监控系统，角点检测作为计算机视觉领域的基础技术之一，其应用范围日益广泛。在本文中，我们将聚焦于一种经典的角点检测算法——Shi-Tomasi角点检测算法，并以箱子角点检测为例，探讨其在实际应用中的效果和优势。Shi-Tomasi角点检测算法是基于Harris角点检测算法改进而来的一种高效、稳定的角点检测方法。
力扣（leetcode）每日一题 1014 最佳观光组合
ganjiee0007的博客
09-23 489
对找下标i右边的最大值进行预先处理，达到复用。也算是记忆搜索的一种。属于简单题目。
Java算法每日一题——搜索插入位置
Java技术加油站的博客
09-27 429
Java算法每日一题——搜索插入位置。给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为。
TypeScript 算法手册【插入排序】
bobostudio1995的博客
10-01 853
插入排序是一种简单直观的排序算法，类似于我们整理图书馆的书架，当你面对一排杂乱无章的书籍时，该如何整理它们?我们可能会这样做：从左到右一本一本来，拿起一本书，将它插入到已经按照特定顺序排列好的书籍中的正确位置，这就是插入排序的基本思想。i < len;i++) {j--;return arr;插入排序虽然在大规模数据排序中不如一些高级算法高效，它在某些特定场景下仍然有其独特的优势。当数据规模较小或者数据已经基本有序时，插入排序可能会比一些复杂的排序算法更快。
python 实现2D变换算法
luthane的博客
09-30 811
2D变换算法在计算机图形学和统计机器学习中扮演着重要角色，主要涉及图像的平移、旋转、放缩、仿射变换和射影变换等。1. 平移（Translation）平移是指将图像或图像中的每个点按照指定的向量进行移动。在2D空间中，平移可以通过增加点的横坐标（x）和纵坐标（y）来实现。
力扣 简单 111.二叉树的最小深度
qq_51352130的博客
09-28 301
最小深度：从根节点到最近叶子结点的最短路径上节点数量return 0;// 如果 node 没有右儿子，那么最小深度就是左子树的最小深度加一// 如果 node 左右子树都有。
代码随想录算法训练营
08-23
代码随想录算法训练营是一个优质的学习和讨论平台，提供了丰富的算法训练内容和讨论交流机会。在训练营中，学员们可以通过观看视频讲解来学习算法知识，并根据讲解内容进行刷题练习。此外，训练营还提供了刷题建议，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值