代码随想录训练营Day18|树：513.找树左下角的值、112.路径总和、113.路径总和2、106.从中序和后序遍历序列构造二叉树、105.从前序和中序遍历序列构造二叉树

已于 2023-10-22 14:44:20 修改
阅读量57 收藏
点赞数
文章标签： leetcode 算法 数据结构
于 2023-05-06 22:37:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40837128/article/details/130536263
版权

LeetCode513:找树的左下角的值

思路：利用层序遍历，每次result记录最左侧的节点，到最后一层result就更新为树的左下角。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int findBottomLeftValue(TreeNode root) {
        if(root == null){
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int result = root.val;
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                if(i==0){// 记录最左侧节点的值
                    result = node.val;
                }
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
            }
        }
        return result;
    }
}

层序遍历会更加简单一点。

/**
 * 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:
    int findBottomLeftValue(TreeNode* root) {
        int ans = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i=0;i<size;i++){
                TreeNode* node = que.front();
                if(i==0){
                    ans = node->val;
                }
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return ans;
    }
};

LeetCode112:路径总和

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        // 递归+回溯
        if(root == null){
            return false;
        }
        boolean ans = helper(root, targetSum - root.val);// 在开始的位置对root特殊处理。不能放到里面去处理 会重复减。
        return ans;
    }
    public boolean helper(TreeNode node, int number){
        // 递归终止条件
        if(node.left == null && node.right == null && number == 0){
            return true;
        }
        else if(node.left == null && node.right == null && number != 0){
            return false;
        } 
        if(node.left!=null){
            number -= node.left.val; // 
            if(helper(node.left, number)){
                return true;
            }
            number += node.left.val; // 回溯
        }
        if(node.right!=null){
            number -= node.right.val;
            if(helper(node.right, number)){
                return true;
            }
            number += node.right.val;
        }
        return false;
    }
}

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 {
private:
    bool getPath(TreeNode* node, int targetSum){
        // 递归的结束条件 有两个：
        // 1. 到了叶子节点 找到了；2. 到了叶子节点没有找到
        if(targetSum == 0 && node->left == NULL && node->right == NULL) return true;
        else if(targetSum != 0 && node->left == NULL && node->right == NULL) return false;
        if(node->left){
            if(getPath(node->left, targetSum - node->left->val)) // 如果下一层返回的是true 就直接向上返回true。 而且这里最好是这样写判断 不要在想之前一样写一个bool left再放到后面return 判断。
                return true;
        }
        if(node->right){
            if(getPath(node->right, targetSum - node->right->val))
                return true;
        }
        return false;
    }
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == NULL) return false;
        bool ans = getPath(root, targetSum-root->val);
        return ans;
    }


};

LeetCode113路径总和2

思路：与上题基本一致，只不过返回的结果是具体的路径。所以更能体现回溯的价值。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
            // 
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        if(root == null){
            return ans;
        }
        List<Integer> temp = new LinkedList<>();
        helper(root, targetSum-root.val, ans, temp);
        return ans;        
    
    }
    public void helper(TreeNode node, int number, List<List<Integer>> ans, List<Integer> temp){
        temp.add(node.val);
        if(node.left == null && node.right == null && number == 0){
            List<Integer> temp_ = new ArrayList<>(temp);
            ans.add(temp_);
        }
        else if(node.left == null && node.right == null && number!=0){
            return;
        }
        if(node.left != null){
            helper(node.left, number - node.left.val, ans, temp);
            temp.remove(temp.size() -1);
        }
        if(node.right != null){
            helper(node.right, number- node.right.val, ans, temp);
            temp.remove(temp.size() -1);
        }
    
    }
}

/**
 * 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 {
private:

    void traversal(TreeNode* node, int targetSum, vector<int>& ans_, vector<vector<int>>& ans){
        // 递归结束条件，还是要找到叶子结点判断val是否为零两种情况。
        // 这里的返回值设为viod比较好，不然范围ans_ 还是ans都是很麻烦的事，因此使用全局变量 或者传递这个变量比较好
        if(node->left == NULL && node->right == NULL && targetSum == 0){
            ans.push_back(ans_); // 找到了路径就在此时将找到的路径加到最终的二维数组去
            return;
        }
        if(node->left== NULL && node->right == NULL){
            return;
        }
        if(node->left){
            ans_.push_back(node->left->val); // 先将当前左子节点加到ans_ 里面去
            targetSum -= node->left->val; // 先将当前左子节点的val剪掉，
            traversal(node->left, targetSum, ans_, ans); // 递归，此时判断左子节点下面的路径时候符合要求
            targetSum += node->left->val; // 回溯, 将上一步加进去的左叶子节点值加回去，意味着返回父节点要往右子节点找了
            ans_.pop_back();  // 回溯
        }

        if(node->right){
            ans_.push_back(node->right->val);
            targetSum -= node->right->val;
            traversal(node->right, targetSum, ans_, ans);
            targetSum += node->right->val;
            ans_.pop_back();
        }
        return;
    }
public:
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        // 这里必须用到回溯了，要返回所有的路径情况
        vector<vector<int>> ans;
        vector<int> ans_;
        ans.clear();
        ans_.clear();
        if(root == NULL) return ans;
        ans_.push_back(root->val);  // 根节点在一开始就要加到ans_里面去
        traversal(root, targetSum- root->val, ans_, ans);
        return ans;

    }
};

LeetCode106从中序和后序遍历构造二叉树

思路：
后序确定父节点，中序确定左右子树

  1. 通过后序找到根节点
  2. 通过根节点的值，在中序中遍历将其划分左右子树
  3. 通过左子树大小，在后序中遍历得到左，再得到右，（记得先将根节点删去）
  4. 递归中序和后序的左子树；递归中序和后序的右子树
  5. 返回root

关键点：在数组问题上 会遇见的左闭右开还是左闭右闭的问题，这里用的是左闭右闭。
有很多细节，例如：

  1. 使用public 一个map用来存放数组的值和索引，避免重复创建数组；
  2. 在递归传入参数的时候传递了inorder 和postorder的首位索引注意区间的开闭
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public Map<Integer, Integer> map = new HashMap<>(); 
    // 用map可以方便得到元素在数组中的索引和值。
    // 同时代码中没必要将左右区间都用数组表示出来，只要知道首尾索引就可以
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        for(int i=0;i<inorder.length;i++){
            map.put(inorder[i], i);
        }
        return getNode(inorder, 0, inorder.length -1, postorder, 0, postorder.length-1);// 这里是左闭右闭
    }
    public TreeNode getNode(int[] inorder, int inStart, int inEnd, int[] postorder, int poStart, int poEnd){
        // 后序确定父节点，中序确定左右子树
        // 1. 通过后序找到根节点
        // 2. 通过根节点的值，在中序中遍历将其划分左右子树
        // 3. 通过左子树大小，在后序中遍历得到左，再得到右，（记得先将根节点删去）  
        // 4. 递归中序和后序的左子树；递归中序和后序的右子树
        // 5. 返回root
        if (inStart> inEnd || poStart > poEnd) {  // 不满足左闭右开，说明没有元素，返回空树
            return null;
        }
        // 下面的写法避免了重复创建数组来保存左右区间
        // 但是理解起来麻烦了点
        // 
        int index = map.get(postorder[poEnd]); // 确定父节点的位置
        TreeNode root  = new TreeNode(postorder[poEnd]);
        int indexLeft = index - inStart; // 确定左区间的长度，从而也可以得到有区间的长度。
        root.left = getNode(inorder, inStart, index-1, postorder, poStart, poStart+indexLeft-1);
        root.right = getNode(inorder, index+1,inEnd, postorder, poStart+indexLeft, poEnd-1);
        return root;
    }
}

完整的模板代码 便于理解。

class Solution {
private:
    TreeNode* traversal (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;
        }

        // 切割中序数组
        // 左闭右开区间：[0, delimiterIndex)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        // [delimiterIndex + 1, end)
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );

        // postorder 舍弃末尾元素
        postorder.resize(postorder.size() - 1);

        // 切割后序数组
        // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
        // [0, leftInorder.size)
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        // [leftInorder.size(), end)
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

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

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

LeetCode105从前序和中序遍历序列构造二叉树

同116题一致。注意数组的左开右闭以及在递归时候**传入参数））的细节。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public Map<Integer, Integer> map = new HashMap<>();
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        for(int i=0;i<inorder.length;i++){
            map.put(inorder[i], i);
        }
        return getNode(preorder, 0, preorder.length-1, inorder, 0, inorder.length-1);
    }
    public TreeNode getNode(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd){
        if(preStart>preEnd || inStart>inEnd){
            return null;
        }
        int index = map.get(preorder[preStart]);
        TreeNode root = new TreeNode(preorder[preStart]);
        int lenLeft = index -inStart;
        root.left = getNode(preorder, preStart+1, preStart+lenLeft, inorder, inStart, inStart+lenLeft-1);
        root.right = getNode(preorder,preStart+lenLeft+1, preEnd, inorder, index+1, inEnd);
        return root;
    }
}

/**
 * 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 {
private:
    TreeNode* traversal(vector<int>& preorder, vector<int>& inorder){
        if(preorder.size() == 0) return NULL;

        int nodeValue = preorder[0];
        TreeNode* node =new TreeNode(nodeValue);
        if(preorder.size() == 1)return node;

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

        vector<int> leftinorder(inorder.begin(), inorder.begin()+cutIndex);
        vector<int> rightinorder(inorder.begin()+cutIndex+1, inorder.end());

        vector<int> leftpreorder(preorder.begin()+1, preorder.begin()+1 + leftinorder.size());
        vector<int> rightpreorder(preorder.begin()+1+leftinorder.size(), preorder.end());

        node->left = traversal(leftpreorder, leftinorder);
        node->right = traversal(rightpreorder, rightinorder);
        return node;
    }
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
            if(preorder.size() == 0 || inorder.size() == 0) return NULL;
            return traversal(preorder, inorder);
    }
};
小胡爱喝水
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录算法训练营第一天 - 704. 二分查找
05-08
代码随想录算法训练营第一天 - 704. 二分查找
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录算法训练营day18|513.找树左下角的值、112. 路径总和 113.路径总和ii
weixin_64883584的博客
02-19 485
可以使用前序遍历（当然中序，后序都可以，因为本题没有 中间节点的处理逻辑，只要左优先就行），保证优先左边搜索，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。本题还需要类里的两个全局变量，maxLen用来记录最大深度，result记录最大深度最左节点的数值。图中可以看出，遍历的路线，并不要遍历整棵树，所以递归函数需要返回值，可以用bool类型表示。当遇到叶子节点的时候，就需要统计一下最大的深度了，所以需要遇到叶子节点来更新最大深度。在找最大深度的时候，递归的过程中依然要使用回溯。
代码随想录算法训练营Day16||Leecode513.找树左下角的值、Leecode112.路径总和、Leecode106.中序后序构造二叉树
jiegongzhu3z的博客
07-18 85
递归三部曲：第一步 返回值类型为空，参数需要传入每次开始的节点指针，和与已存最大深度比较的depth 第二步 确定终止条件为找到叶子节点，找到后需要变更最大深度，然后用result记录当前节点的值。经过我的思考和视频讲解，我认为，首先是因为maxdepth这个变量的存在，控制了同一层的节点之间比较，然后因为先遍历左侧，然后遍历右侧，这使得在同一层的情况下，先记录的节点值一定是左侧节点的值。第三步 单层循环逻辑为左遍历：每次减去左/右节点的数，然后判断其子树返回值是否为真，然后递归后回溯。
代码随想录算法训练营day18 || 513.找树左下角的值，112.路径总和，106.从中序和后序序列构造二叉树
旭
01-14 475
而对于深度优先遍历，需要额外明确的一点就是，对于deep层，其最底层、最左边的节点一定是在遍历到达一个新的层次时当前指针所指向的节点，其原因在于深度优先是路径优先的遍历方式，因此如果存在可访问到deep层的路径，则在当前路径之前已经出现了访问deep的记录，但是现在并没有deep层的信息出现，直到当前路径的出现，所以最小的节点就是每一次到层新的层次了所访问的第一个节点。思路：类似于 257. 二叉树的所有路径，是一样的道理，这里只不过是对于路径上面的每个元素不经是存储，还需要相加。思路：题目的目标是找。
代码随想录算法训练营Day16 | LeetCode 513. 找树左下角的值 | 112. 113 路径总和 | 106. 从中序与后序遍历序列构造二叉树
wonderlandlja的博客
07-07 654
【代码】代码随想录算法训练营Day16 | LeetCode 513. 找树左下角的值 | 112. 113 路径总和 | 106. 从中序与后序遍历序列构造二叉树。
代码随想录算法训练营Day18:513.找树左下角的值，112.路径总和，106.从中序与后序遍历序列构造二叉树
weixin_57956443的博客
12-24 134
代码随想录算法训练营Day18:513.找树左下角的值，112.路径总和，106.从中序与后序遍历序列构造二叉树
代码随想录算法训练营day16 | 513.找树左下角的值、112. 路径总和、113. 路径总和 II、106.从中序与后序遍历序列构造二叉树
最新发布
weixin_45182267的博客
07-18 161
碎碎念：加油！！！
代码随想录算法训练营Day14 | 513.找树左下角的值，112. 路径总和，106.从中序与后序遍历序列构造二叉树
菜鸟一枚
07-10 139
【代码】代码随想录算法训练营Day14 | 513.找树左下角的值，112. 路径总和，106.从中序与后序遍历序列构造二叉树。
代码随想录算法训练营day21 | 513.找树左下角的值、112. 路径总和、106.从中序与后序遍历序列构造二叉树
sunflowers11的博客
05-11 274
迭代法比较简单，层序遍历，找到最下面一层的第一个节点。题目已经说明节点数>=1了递归法题解中遇到叶子节点并且当前深度比最大深度更大时更换结果值，但是最深的节点必定是叶子节点，所以不必判断是叶子节点。
代码随想录算法训练营Day 16|Python|513.找树左下角的值, 112. 路径总和，113.路径总和II, 106.从中序与后序遍历序列构造二叉树, 105.从前序与中序遍历序列构造二
qq_60959261的博客
04-06 276
根据中序遍历和后序遍历的特性，后序遍历的最后一个node一定是中介的根节点，因此在中序遍历中定位该node的index，以此区分左右子树得到left_in, right_in。注意中序遍历中左右子树的长度与后序遍历中左右子树的长度相同，因此可以在后序遍历中区分左右子树得到left_post, right_post，将left_in, left_post与right_in, right_post放入递归，返回root。的路径，这条路径上所有节点值相加等于目标和。层序遍历，return最后一行的第一个值。
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
00.代码随想录-最强八股文-第3版-无密版本.pdf
07-11
"代码随想录知识星球精华（最强八股文）第三版" 本资源摘要信息中，我们将根据给定的文件信息，生成相关知识点。 标题和描述中的知识点 * 代码随想录知识星球精华（最强八股文）第三版：这是一个关于编程的知识...
力扣224.基本计算器
Pisasama的博客
07-14 229
【代码】力扣224.基本计算器。
力扣-bfs
weixin_63551790的博客
07-12 528
何为广度优先搜索？广度优先搜索，即bfs。不同于dfs（走到底然后再换另外一条路），bfs更像是一层一层的走。常常用来处理最短路径问题。
leetcode_88. 合并两个有序数组
qq_42742845的博客
07-14 885
给你两个按非递减顺序排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你 合并 nums2 到 nums1 中，使合并后的数组同样按非递减顺序排列。
力扣1111.有效括号的嵌套深度
Pisasama的博客
07-14 345
对于。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列，同时将当前层的节点值添加到结果列表中。 综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值