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

最新推荐文章于 2024-11-23 17:42:15 发布
最新推荐文章于 2024-11-23 17:42:15 发布
阅读量759 收藏 2
点赞数 16
分类专栏： 代码随想录算法训练营打卡 文章标签： 算法 leetcode 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wonderlandlja/article/details/140252931
版权

今日任务

513. 找树左下角的值

  • 题目链接： https://leetcode.cn/problems/find-bottom-left-tree-value/description/
  • 题目描述：
    在这里插入图片描述

Code 多种方法

class Solution {
public:
    // int ans;
    // int len = -1;
    // void dfs(TreeNode *node, int depth){
    //     if(node == nullptr){
    //         return;
    //     }
    //     if(len == depth){
    //         len++;
    //         ans = node->val;
    //     }
    //     if(node->left){
    //         dfs(node->left, depth + 1);
    //     }
    //     if(node->right){
    //         dfs(node->right, depth + 1);
    //     }
    // }

    // void dfs(TreeNode *node, int depth){
    //     if(node->left == node->right){
    //         if(depth > len){
    //             len = depth;
    //             ans = node->val;
    //         }
    //         return;
    //     }
    //     if(node->left){
    //         dfs(node->left, depth + 1);
    //     }
    //     if(node->right){
    //         dfs(node->right, depth + 1);
    //     }
    //     return;
    // }
public:
    int findBottomLeftValue(TreeNode* root) {

        // DFS

        // function<void(TreeNode *, int)> dfs = [&] (auto node, auto depth) -> void{
        //     if(node == nullptr){
        //         return;
        //     }
        //     if(len == depth){
        //         len++;
        //         ans = node->val;
        //     }
        //     if(node->left){
        //         dfs(node->left, depth + 1);
        //     }
        //     if(node->right){
        //         dfs(node->right, depth + 1);
        //     }
        // };
        dfs(root, 0);
        return ans;

        // BFS
        TreeNode *node = nullptr;
        queue<TreeNode *> que;
        que.emplace(root);
        while(!que.empty()){
            node = que.front();
            que.pop();
            if(node->right){
                que.emplace(node->right);
            }
            if(node->left){
                que.emplace(node->left);
            }
        }
        return node->val;
    }
};

112 113. 路径总和

  • 题目链接： https://leetcode.cn/problems/path-sum/description/
  • 题目描述：
    在这里插入图片描述
    在这里插入图片描述

Code 112 递归 + 迭代

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        // if(root == nullptr){
        //     return false;
        // }
        // bool ans = false;
        // function<void(TreeNode *, int)> dfs = [&](auto node, auto sum)->void{
        //     if(node->left == node->right){
        //         if(sum + node->val == targetSum){
        //             ans = true;
        //         }
        //         return ;
        //     }
        //     if(ans){
        //         return;
        //     }
        //     if(node->left){
        //         dfs(node->left, sum + node->val);
        //     }
        //     if(node->right){
        //         dfs(node->right, sum + node->val);
        //     }
        // };
        // dfs(root, 0);
        // return ans;

        // DFS 简写
        // if(root == nullptr){
        //     return false;
        // }
        // if(root->left == root->right){
        //     return targetSum == root->val;
        // }
        // // 左右子树有一个成立，则整体成立
        // return hasPathSum(root->left, targetSum - root->val) || hasPathSum(root->right, targetSum - root->val);

        // 迭代法
        // if(root == nullptr){
        //     return false;
        // }
        // stack<pair<bool, TreeNode*>> st;
        // st.emplace(make_pair(true, root));
        // int sum = 0;
        // while(!st.empty()){
        //     auto [flag, cur] = st.top();
        //     st.pop();
        //     if(flag){
        //         sum += cur->val;
        //         st.emplace(make_pair(false, cur));
        //         if(cur->right){
        //             st.emplace(make_pair(true, cur->right));
        //         }
        //         if(cur->left){
        //             st.emplace(make_pair(true, cur->left));
        //         }
        //     }else{
        //         if(cur->left == cur->right){
        //             if(sum == targetSum){
        //                 return true;
        //             }
        //         }
        //         sum -= cur->val;
        //     }
        //     cout << sum << endl;
        // }
        // return false;

        // 迭代2
        if(root == nullptr){
            return false;
        }
        stack<pair<TreeNode *, int>> st;
        st.emplace(make_pair(root, root->val));
        while(!st.empty()){
            auto[cur, sum] = st.top();
            st.pop();
            if(cur->left == cur->right){
                if(sum == targetSum){
                    return true;
                }
            }
            if(cur->right){
                st.emplace(make_pair(cur->right, sum + cur->right->val));
            }
            if(cur->left){
                st.emplace(make_pair(cur->left, sum + cur->left->val));
            }
        }
        return false;

        // 迭代3 nullptr模版 + stack<TreeNode *, int>
        // if(root == nullptr){
        //     return false;
        // }
        // stack<pair<TreeNode *, int>> st;
        // st.emplace(make_pair(root, root->val));
        // while(!st.empty()){
        //     auto [cur, sum] = st.top();
        //     st.pop();
        //     if(cur){
        //         if(cur->right){
        //             st.emplace(make_pair(cur->right, sum + cur->right->val));
        //         }
        //         if(cur->left){
        //             st.emplace(make_pair(cur->left, sum + cur->left->val));
        //         }
        //         st.emplace(make_pair(cur, sum));
        //         st.emplace(make_pair(nullptr, -1));
        //     }else{
        //         auto [tmp, cnt] = st.top();
        //         st.pop();
        //         if(tmp->left == tmp->right && cnt == targetSum){
        //             return true;
        //         }
        //     }
        // }
        // return false;
    }
};

Code 113

class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if(root == nullptr){
            return {};
        }
        // vector<vector<int>> ans;
        // vector<int> path;
        // function<void(TreeNode *, int)> dfs = [&](auto node, auto sum)->void{
        //     if(node == nullptr){
        //         return;
        //     }
        //     path.emplace_back(node->val);
        //     if(node->left == node->right && sum == node->val){
        //         ans.emplace_back(path);
        //         path.pop_back();
        //         return;
        //     }
        //     dfs(node->left, sum - node->val);
        //     dfs(node->right, sum - node->val);
        //     path.pop_back();
        // };
        // dfs(root, targetSum);
        // return ans;

        // 迭代
        vector<vector<int>> ans;
        stack<pair<TreeNode *, int>> st;
        st.emplace(make_pair(root, root->val));
        vector<int> path;
        while(!st.empty()){
            auto[cur, sum] = st.top();
            st.pop();
            if(cur){
                path.emplace_back(cur->val);
                st.emplace(make_pair(cur, sum));
                st.emplace(make_pair(nullptr, -1));
                if(cur->right){ 
                    st.emplace(make_pair(cur->right, sum + cur->right->val));
                }
                if(cur->left){
                    st.emplace(make_pair(cur->left, sum + cur->left->val));
                }
            }else{
                auto [tmp, cnt] = st.top();
                st.pop();
                if(tmp->left == tmp->right && cnt == targetSum){
                    ans.emplace_back(path);
                }
                path.pop_back();
            }
        }
        return ans;
    }
};

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

  • 题目链接： https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/description/
  • 题目描述：
    在这里插入图片描述

Code

class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(postorder.empty()){
            return nullptr;
        }
        int left_size = ranges::find(inorder, postorder.back()) - inorder.begin();
        vector<int> in1(inorder.begin(), inorder.begin() + left_size);
        vector<int> in2(inorder.begin() + left_size + 1, inorder.end());
        vector<int> post1(postorder.begin(), postorder.begin() + left_size);
        vector<int> post2(postorder.begin() + left_size, postorder.end() - 1);
        TreeNode *left = buildTree(in1, post1);
        TreeNode *right = buildTree(in2, post2);
        return new TreeNode(postorder.back(), left, right);
    }
};
wonderlandlja
关注
专栏目录
【代码随想录训练营】【Day18】第六章｜二叉树｜513.找树左下角的值｜112. 路径总和｜113.路径总和ii｜105.从前序与中序遍历序列构造二叉树｜106.从中序与后序遍历序列构造二叉树
士多啤梨先生の博客
02-18 1492
【代码随想录训练营】【Day18】第六章｜二叉树｜513.找树左下角的值｜112. 路径总和｜113.路径总和ii｜105.从前序与中序遍历序列构造二叉树｜106.从中序与后序遍历序列构造二叉树
算法训练Day50 | LeetCode123. 买卖股票的最佳时机III（最多买卖2次）；LeetCode188. 买卖股票的最佳时机IV（最多买卖K次）
weixin_47284299的博客
11-09 1806
算法训练Day50 | LeetCode123. 买卖股票的最佳时机III（最多买卖2次）；LeetCode188. 买卖股票的最佳时机IV（最多买卖K次）
代码随想录算法训练营Day16 | 二叉树 513.找树左下角的值 112.路径总和 106.从中序与后续遍历序列构造二叉树
weixin_65053787的博客
07-21 568
二叉树。513.找树左下角的值 112.路径总和 106.从中序与后续遍历序列构造二叉树给定一个二叉树，在树的最后一行找到最左边的值。在树的最后一行找到最左边的值。
代码随想录算法训练营Day16 | Leetcode 513 找树左下角的值 Leetcode 112 路径总和 Leetcode 106 中后序创建二叉树
m0_74853141的博客
08-01 570
写递归不能试图模拟每层递归，必须相信递归能做到我们想象的功能，然后把问题简化成最深层递归和最外层初始情况。递归是一个需要时间来理解的算法，明天必须开始数据库和计网的学习了。
代码随想录算法训练营day16 | 力扣513.找树左下角的值、力扣112. 路径总和、力扣106.从中序与后序遍历序列构造二叉树
Xiaoxiaodezhuren的博客
11-15 138
记录深度depth，每到depth比dp值更大时，说明遍历到更下一层，此时更新res的值。因为是先左后右遍历，每层先遍历的一定是最左边的结点。方法一和方法二思路相同，都是根据“因为是先左后右遍历，每层先遍历的一定是最左边的结点”这种特性而来，实现不同。如下代码在结点值不重复的情况可以，结点值重复，会导致for循环查找中结点下标有二义性。求路径问题只能用前序，两种方法都是前序，只是每次递归cnt的处理不同。注意区间定义，区间定义永远不变，这里用左闭右开区间。一定要明确左下角结点的定义。
代码随想录算法训练营day18 || 513.找树左下角的值，112.路径总和，106.从中序和后序序列构造二叉树
旭
01-14 573
而对于深度优先遍历，需要额外明确的一点就是，对于deep层，其最底层、最左边的节点一定是在遍历到达一个新的层次时当前指针所指向的节点，其原因在于深度优先是路径优先的遍历方式，因此如果存在可访问到deep层的路径，则在当前路径之前已经出现了访问deep的记录，但是现在并没有deep层的信息出现，直到当前路径的出现，所以最小的节点就是每一次到层新的层次了所访问的第一个节点。思路：类似于 257. 二叉树的所有路径，是一样的道理，这里只不过是对于路径上面的每个元素不经是存储，还需要相加。思路：题目的目标是找。
代码随想录算法训练营day18 | LeetCode 513. 找树左下角的值 112. 路径总和 106. 从中序与后序遍历序列构造二叉树
DSZ___的博客
07-29 187
思路：典型的二叉树便利题，可以考录用递归或者迭代，递归的话就是正常的前序遍历或者中序遍历，但是都需要定义一个全局变量记录深度，当每第一次达到最大深度时（遍历到叶子节点的时候）记录该节点的值。迭代就是用层序便利了，每次拿出每层第一个节点的值记录下来，当层序遍历完，最后一次赋的值也就是数左下角的值了。思路：典型的回溯法，首先讲递归的做法，每次迭代要传给子树的参数包括节点指针、到本节点为止的值的和，遍历到叶子结点时进行判断。第二种迭代的做法，其实有点画蛇添足，比递归做法要复杂不少，但也算锻炼对树的遍历算法练习。
代码随想录算法训练营Day16 | 513.找树左下角的值、112. 路径总和、106.从中序与后序遍历序列构造二叉树
Harryline的博客
11-14 369
代码随想录算法训练营Day16 | 513.找树左下角的值、112. 路径总和、106.从中序与后序遍历序列构造二叉树
代码随想录算法训练营day18|513.找树左下角的值、112. 路径总和 113.路径总和ii
weixin_64883584的博客
02-19 578
可以使用前序遍历（当然中序，后序都可以，因为本题没有 中间节点的处理逻辑，只要左优先就行），保证优先左边搜索，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。本题还需要类里的两个全局变量，maxLen用来记录最大深度，result记录最大深度最左节点的数值。图中可以看出，遍历的路线，并不要遍历整棵树，所以递归函数需要返回值，可以用bool类型表示。当遇到叶子节点的时候，就需要统计一下最大的深度了，所以需要遇到叶子节点来更新最大深度。在找最大深度的时候，递归的过程中依然要使用回溯。
代码随想录算法训练营Day14 | 513.找树左下角的值，112. 路径总和，106.从中序与后序遍历序列构造二叉树
菜鸟一枚
07-10 242
【代码】代码随想录算法训练营Day14 | 513.找树左下角的值，112. 路径总和，106.从中序与后序遍历序列构造二叉树。
代码随想录算法训练营Day18|leetcode513 找树左下角的值、leetcode112 路经总和、leetcode106 从中序与后序遍历序列构造二叉树
weixin_48821824的博客
08-27 243
题目链接思路：找左下角的值就是最后一行最左侧得值，也就是深度最大的最左边。代码逻辑为最大深度初始化为int的最小值，方便比较，定义一个result记录当前最大深度结点的值，depth记录当前遍历的深度。定义一个函数，如果走到了叶子节点，对比此时的深度和最大深度，如果此时深度更大就更新最大深度并更新result里面的值，然后分别递归左右节点，递归函数后面要进行回溯，因为找完一条路之后要回去找另外一条路。
linzeliang1222#LeetCode#Day16-512.找树左下角的值1
07-25
复杂度分析时间复杂度：$O(N)$，其中 N 为树的结点数量空间复杂度：$O(N)$，其中 N 为树的结点数量思路2（DFS 深度优先搜索）使用 DFS + 回
算法训练Day49 | Leetcode121. 买卖股票的最佳时机（只能买卖一次）；LeetCode122. 买卖股票的最佳时机II（可以买卖多次）
weixin_47284299的博客
11-09 1550
算法训练Day49 | Leetcode121. 买卖股票的最佳时机（只能买卖一次）；LeetCode122. 买卖股票的最佳时机II（可以买卖多次）
代码随想录算法训练营第三十四天 | LeetCode 51、37
Bingjiaokong的博客
01-30 1192
代码随想录刷题-day34
真题-桂城2022年五年级
chenyuanxinde的博客
11-22 984
小辉制作了一个显示器，该显示器显示的数值 a_1 , a_2 , a_3 ... , a_na1​,a2​,a3​...,an​ 是一开始就植入的,并会按照次序依次循环显示，每秒变化 1 次。也就是说，该显示器显示的数值是按照以下规律变化的: a_1a1​ -> a_2a2​ -> a_3a3​ ->... -> a_nan​ -> a_1a1​ -> a_2a2​ -> a_nan​ -> a_1a1​ ......小辉是一个实验爱好者。100% 的数据，1<= a , b , c <= 100000。
二分排序
最新发布
2301_77869606的博客
11-23 458
二分问题之前遇到很多次了，不过一直是手写完整二分，现在转变一下想法，直接使用函数lower_bound和upper_bound更方便查找第一个不小于指定值的位置。
小南找书
ROBIN__dyc的博客
11-21 291
创建过程中使用的循环嵌套可能导致调试困难；编号比较时每次需包含大量运算，效率较低。2.编号自减（上述程序展示的方法）1.创建二维数组，进行编号的比较。
【LC】2529. 正整数和负整数的最大计数
Chuanqi_Pang的博客
11-20 233
给你一个按排列的数组nums，返回正整数数目和负整数数目中的最大值。换句话讲，如果nums中正整数的数目是pos，而负整数的数目是neg，返回pos和neg二者中的最大值。0既不是正整数也不是负整数。
面向对象程序填空
workflower的博客
11-23 933
friend ostream& operator<<(ostream& os, Student s){ //要求输出格式如：Peter, 25。MyArray(int size, int initVal = 0){//初始化所有数组元素的值为initVal。//此处略去更多的成员函数。
代码随想录算法训练营第二十二天
09-13
第二十二天的算法训练营主要涵盖了Leetcode题目中的三道题目，分别是Leetcode 28 "Find the Index of the First Occurrence in a String"，Leetcode 977 "有序数组的平方"，和Leetcode 209 "长度最小的子数组"。 首先是Leetcode 28题，题目要求在给定的字符串中找到第一个出现的字符的索引。思路是使用双指针来遍历字符串，一个指向字符串的开头，另一个指向字符串的结尾。通过比较两个指针所指向的字符是否相等来判断是否找到了第一个出现的字符。具体实现的代码如下： ```python def findIndex(self, s: str) -> int: left = 0 right = len(s) - 1 while left <= right: if s[left == s[right]: return left left += 1 right -= 1 return -1 ``` 接下来是Leetcode 977题，题目要求对给定的有序数组中的元素进行平方，并按照非递减的顺序返回结果。这里由于数组已经是有序的，所以可以使用双指针的方法来解决问题。一个指针指向数组的开头，另一个指针指向数组的末尾。通过比较两个指针所指向的元素的绝对值的大小来确定哪个元素的平方应该放在结果数组的末尾。具体实现的代码如下： ```python def sortedSquares(self, nums: List[int]) -> List[int]: left = 0 right = len(nums) - 1 ans = [] while left <= right: if abs(nums[left]) >= abs(nums[right]): ans.append(nums[left ** 2) left += 1 else: ans.append(nums[right ** 2) right -= 1 return ans[::-1] ``` 最后是Leetcode 209题，题目要求在给定的数组中找到长度最小的子数组，使得子数组的和大于等于给定的目标值。这里可以使用滑动窗口的方法来解决问题。使用两个指针来表示滑动窗口的左边界和右边界，通过移动指针来调整滑动窗口的大小，使得滑动窗口中的元素的和满足题目要求。具体实现的代码如下： ```python def minSubArrayLen(self, target: int, nums: List[int]) -> int: left = 0 right = 0 ans = float('inf') total = 0 while right < len(nums): total += nums[right] while total >= target: ans = min(ans, right - left + 1) total -= nums[left] left += 1 right += 1 return ans if ans != float('inf') else 0 ``` 以上就是第二十二天的算法训练营的内容。通过这些题目的练习，可以提升对双指针和滑动窗口等算法的理解和应用能力。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值