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

最新推荐文章于 2024-10-05 12:29:44 发布
最新推荐文章于 2024-10-05 12:29:44 发布
阅读量45 收藏
点赞数
文章标签： leetcode 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64566993/article/details/132266484
版权

 找树左下角的值  

        题目链接：513. 找树左下角的值 - 力扣（LeetCode）

        代码随想录题目解析：代码随想录 (programmercarl.com)

具体代码实现：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

//给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

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 Solution1 {
    private int Deep = -1;
    private int value = 0;
    public int findBottomLeftValue(TreeNode root) {
        value = root.val;
        findLeftValue(root,0);
        return value;
    }

    private void findLeftValue (TreeNode root,int deep) {
        if (root == null) return;
        if (root.left == null && root.right == null) {
            if (deep > Deep) {
                value = root.val;
                Deep = deep;
            }
        }
        if (root.left != null) findLeftValue(root.left,deep + 1);
        if (root.right != null) findLeftValue(root.right,deep + 1);
    }
}

//迭代法
class Solution2 {

    public int findBottomLeftValue(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int res = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode poll = queue.poll();
                if (i == 0) {
                    res = poll.val;
                }
                if (poll.left != null) {
                    queue.offer(poll.left);
                }
                if (poll.right != null) {
                    queue.offer(poll.right);
                }
            }
        }
        return res;
    }
}
public class Solution_text {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个完全二叉树的节点值（按层序遍历顺序输入，空节点用null表示）：");
        String[] values = scanner.nextLine().trim().split(" ");
        int index = 0;
        TreeNode root = buildTree(values, index);

        Solution1 solution1 = new Solution1();
        int res = solution1.findBottomLeftValue(root);
        System.out.println("该二叉树的 最底层 最左边 节点的值:" + res);
        
        Solution2 solution2 = new Solution2();
        System.out.println("该二叉树的 最底层 最左边 节点的值:" + solution2.findBottomLeftValue(root));

        scanner.close();

    }

    private static TreeNode buildTree(String[] values, int index) {
        if (index >= values.length || values[index].equals("null")) {
            return null;
        }

        int val = Integer.parseInt(values[index]);
        TreeNode node = new TreeNode(val , buildTree(values, 2 * index + 1) , buildTree(values, 2 * index + 2));

        return node;
    }

}

 路径总和 ，路径总和||

        题目链接：112. 路径总和 - 力扣（LeetCode）113. 路径总和 II - 力扣（LeetCode）

        代码随想录题目解析：代码随想录 (programmercarl.com)

具体代码实现：


import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Scanner;


//112 判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 
//113 输出所有 从根节点到叶子节点 路径总和等于给定目标和的路径

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 Solution112 {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if (root == null) {
            return false;
        }
        targetSum -= root.val;
        // 叶子结点
        if (root.left == null && root.right == null) {
            return targetSum == 0;
        }
        if (root.left != null) {
            if (hasPathSum(root.left, targetSum)) {      // 已经找到
// 不用回溯,因为targetSum是定义在递归内的变量，在递归中传递他的副本，在本递归中保持不变，下层递归不影响它的值，只改变他的副本
                return true;							 
            }
        }
        if (root.right != null) {
            if (hasPathSum(root.right, targetSum)) {     // 已经找到
// 不用回溯,因为targetSum是定义在递归内的变量，在递归中传递他的副本，在本递归中保持不变，下层递归不影响它的值，只改变他的副本
                return true;
            }
        }
        return false;
    }
}

class Solution113 {
    public ArrayList<ArrayList<Integer>> pathSum(TreeNode root, int targetSum) {
    	ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if (root == null) return res; // 非空判断

        LinkedList<Integer> path = new LinkedList<Integer>();
        preorderdfs(root, targetSum, res, path);
        return res;
    }

    public void preorderdfs(TreeNode root, int targetSum, ArrayList<ArrayList<Integer>> res, LinkedList<Integer> path) {
        path.add(root.val);
        // 遇到了叶子节点
        if (root.left == null && root.right == null) {
            // 找到了和为 targetSum 的路径
            if (targetSum - root.val == 0) {
                res.add(new ArrayList<Integer>(path));
            }
            return; // 如果和不为 targetSum，返回
        }

        if (root.left != null) {
            preorderdfs(root.left, targetSum - root.val, res, path);
            path.remove(path.size() - 1); // 回溯,因为path是定义在递归外的变量，在递归中要手动回溯
        }
        if (root.right != null) {
            preorderdfs(root.right, targetSum - root.val, res, path);
            path.remove(path.size() - 1); // 回溯,因为path是定义在递归外的变量，在递归中要手动回溯
        }
    }
}

public class Solution_text {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个完全二叉树的节点值（按层序遍历顺序输入，用“，”分割，空节点用null表示）：");
        String[] values = scanner.nextLine().trim().split(",");
        int index = 0;
        TreeNode root = buildTree(values, index);
        
        System.out.println("请输入目标和：");
        int targetSum = scanner.nextInt();

        Solution112 solution112 = new Solution112();
        if(solution112.hasPathSum(root, targetSum))
        	System.out.println("该树中存在根节点到叶子节点点值相加等于目标和的路径 ");
        else
        	System.out.println("该树中不存在根节点到叶子节点点值相加等于目标和的路径 ");
        
        Solution113 solution113 = new Solution113();
        
        for(ArrayList<Integer> i :solution113.pathSum(root,targetSum))
        	System.out.println(i);

        scanner.close();

    }

    private static TreeNode buildTree(String[] values, int index) {
        if (index >= values.length || values[index].equals("null")) {
            return null;
        }

        int val = Integer.parseInt(values[index]);
        TreeNode node = new TreeNode(val , buildTree(values, 2 * index + 1) , buildTree(values, 2 * index + 2));

        return node;
    }

}

 从中序与后序遍历序列构造二叉树 &&从前序与中序遍历序列构造二叉树

        代码随想录题目解析： 代码随想录 (programmercarl.com)
 具体代码实现： 
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;


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;
	}
}

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

class Solution106 {
    Map<Integer, Integer> map;  // 方便根据数值查找位置
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        map = new HashMap<Integer, Integer>();
        for (int i = 0; i < inorder.length; i++) { // 用map保存中序序列的数值对应位置
            map.put(inorder[i], i);
        }

        return findNode(inorder,  0, inorder.length, postorder,0, postorder.length);  // 前闭后开
    }

    public TreeNode findNode(int[] inorder, int inBegin, int inEnd, int[] postorder, int postBegin, int postEnd) {
        // 参数里的范围都是前闭后开
        if (inBegin >= inEnd || postBegin >= postEnd) {  // 不满足左闭右开，说明没有元素，返回空树
            return null;
        }
        int rootIndex = map.get(postorder[postEnd - 1]);  // 找到后序遍历的最后一个元素在中序遍历中的位置
        TreeNode root = new TreeNode(inorder[rootIndex]);  // 构造结点
        int lenOfLeft = rootIndex - inBegin;  // 保存中序左子树个数，用来确定后序数列的个数
        
        //中序被分为[左中序，右中序]，即[[inBegin,rootIndex）,[rootIndex+1,inEnd）]   
        //注意左闭右开，相当于数学符号中的[inBegin,rootIndex-1]和[rootIndex+1,inorder.length-1]，去除了rootIndex也就是根
        
        //后序被分为[左后序，右后序]，即[[postBegin,postBegin+lenOfLeft）,[postBegin+lenOfLeft,inEnd-1）]   
        //注意左闭右开，相当于数学符号中的[postBegin,postBegin+lenOfLeft-1]和[postBegin+lenOfLeft,inEnd-2]，去除了inEnd-1,也就是根
        root.left = findNode(inorder, inBegin, rootIndex,                       //左中序
                            postorder, postBegin, postBegin + lenOfLeft);       //左后序
        root.right = findNode(inorder, rootIndex + 1, inEnd,					//右中序
                            postorder, postBegin + lenOfLeft, postEnd - 1);		//右后序

        return root;
    }
}

class Solution105 {
    Map<Integer, Integer> map;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        map = new HashMap<Integer, Integer>();
        for (int i = 0; i < inorder.length; i++) { // 用map保存中序序列的数值对应位置
            map.put(inorder[i], i);
        }

        return findNode(preorder, 0, preorder.length, inorder,  0, inorder.length);  // 前闭后开
    }

    public TreeNode findNode(int[] preorder, int preBegin, int preEnd, int[] inorder, int inBegin, int inEnd) {
        // 参数里的范围都是前闭后开
        if (preBegin >= preEnd || inBegin >= inEnd) {  // 不满足左闭右开，说明没有元素，返回空树
            return null;
        }
        int rootIndex = map.get(preorder[preBegin]);  // 找到前序遍历的第一个元素在中序遍历中的位置
        TreeNode root = new TreeNode(inorder[rootIndex]);  // 构造结点
        int lenOfLeft = rootIndex - inBegin;  // 保存中序左子树个数，用来确定前序数列的个数
        
        //前序被分为[左前序，右前序]，即[[preBegin + 1, preBegin + lenOfLeft + 1),[preBegin + lenOfLeft + 1, preEnd)]
        //注意左闭右开，相当于数学符号中的 [preBegin + 1, preBegin + lenOfLeft],[preBegin + lenOfLeft + 1, preEnd-1],去除了preBegin，也就是根
        
        //中序被分为[左中序，右中序]，即[[inBegin,rootIndex）,[rootIndex+1,inEnd）]   
        //注意左闭右开，相当于数学符号中的[inBegin,rootIndex-1]和[rootIndex+1,inorder.length-1]，去除了rootIndex也就是根
        
        root.left = findNode(preorder, preBegin + 1, preBegin + lenOfLeft + 1,    //左前序
                            inorder, inBegin, rootIndex);						  //左中序
        root.right = findNode(preorder, preBegin + lenOfLeft + 1, preEnd,	      //右前序
                            inorder, rootIndex + 1, inEnd);						  //右中序

        return root;
    }
}
public class Solution_text {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入二叉树的前序遍历数组(数之间用，隔开)：");
        String[] pre = scanner.nextLine().trim().split(",");
        int[] preorder = convertToIntArray(pre);
        
        System.out.println("请输入二叉树的中序遍历数组(数之间用，隔开)：");
        String[] in = scanner.nextLine().trim().split(",");
        int[] inorder = convertToIntArray(in);
        
        System.out.println("请输入二叉树的后序遍历数组(数之间用，隔开)：");
        String[] pos = scanner.nextLine().trim().split(",");
        int[] posorder = convertToIntArray(pos);
        
        System.out.println("106，按照中序和后续层序遍历输出节点值：");
        Solution106 solution106 = new Solution106();
        levelOrderTraversal(solution106.buildTree(inorder, posorder));
        
        System.out.println("105，按照中序和前续层序遍历输出节点值：");
        Solution105 solution105 = new Solution105();
        levelOrderTraversal(solution105.buildTree(preorder, inorder));
        
        scanner.close();

    }

    public static void levelOrderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }

        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();

            if (node == null) {
                System.out.print("null ");
                continue; // 跳过后续处理，直接进入下一次循环
            }

            System.out.print(node.val + " ");

            queue.offer(node.left);
            queue.offer(node.right);
        }
        System.out.print("\n");
    }

	public static int[] convertToIntArray(String[] stringArray) {
        int[] intArray = new int[stringArray.length];
        for (int i = 0; i < stringArray.length; i++) {
            intArray[i] = Integer.parseInt(stringArray[i]);
        }
        return intArray;
    }

}

要动手啊
关注
代码随想录算法训练营第19天 | LeetCode.513.找树左下角的值、LeetCode.112.113.路径总和II、III、LeetCode.106.从中序与后序遍历构造二叉树
m0_61649203的博客
04-02 56
参数需要TreeNode root，int result（记录叶子结点的值）， int depth（因为和层序遍历不同，递归法并不知道到自己当前处于第几层，所以需要一个遍历进行记录对比）注意点：从后序数组中找到的切割点，一定要先切中序数组，因为中序数组的遍历顺序是左--中--右，找到的这个切割点就是中，它把左右子数清晰的分开，这样才能进行下一次切割。当已知一个二叉树的中序遍历和后序遍历就可以确定唯一一个二叉树，因为中序遍历可以将二叉树的左右孩子分开，后序遍历可以直到每个左右孩子的双亲结点。
代码随想录算法训练营第十八天| 513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树、105.从前序与中序遍历序列构造二叉树
qq_51395785的博客
02-16 973
【代码】代码随想录算法训练营第十八天| 513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树、105.从前序与中序遍历序列构造二叉树。
代码随想录算法训练营第十八天 | 513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树、105.从前序与中序遍历序列构造二叉树
Danny_8的博客
05-26 1131
之前准备面试落下好几天的任务，这两天的博客就简单写了，具体思路注释在代码里。本题也是没有对中结点的处理所以前中后序遍历都可以。
代码随想录第18天|513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树、105.从前序与中序遍历序列构造二叉树
m0_57302307的博客
11-07 43
【代码】代码随想录第18天|513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树、105.从前序与中序遍历序列构造二叉树。
代码随想录算法训练营第十六天|513.找树左下角的值，112. 路径总和，113.路径总和ii，106.从中序与后序遍历序列构造二叉树，105.从前序与中序遍历序列构造二叉树
weixin_47748259的博客
01-28 834
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。核心思想：遍历节点的同时保留层数，如果层数比之前得到的最大层数更大，则更新层数，当遍历到叶子节点时，返回当前节点的值即可。给定一个二叉树的根节点 root，请找出该二叉树的最底层最左边节点的值。
代码随想录算法训练营day18| LeetCode 513 找树左下角的值 、LeetCode 112 路径总和、LeetCode 113 路径总和 II等
qq_51588716的博客
02-18 161
代码随想录算法训练营day18
代码随想录算法训练营day18 | 513.找树左下角的值，112. 路径总和 113.路径总和ii，106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树
2301_77450803的博客
04-23 62
【513.找树左下角的值】：第一反应应该就是使用层序遍历求解，但是使用dfs求解的做法也是很不错的，记录最深的深度以及val，中序遍历在depth大于maxdepth是进行更新即可【112. 路径总和 113.路径总和ii】：递归查找，每次target减少节点值，进行回溯搜索。
代码随想录算法训练营第十八天|513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树、105.从前序与中序遍历序列构造二叉树
shanshe7934的博客
10-30 56
递归的方式：使用递归法深度最大的叶子节点就是最后一行，所以要找深度最大的叶子节点。直接使用层序遍历，左边第一个节点的值就是层序遍历之后最下层列表的第一位。写代码的时把切数组的结果都打印出来，如左中序、右中序；使用递归+回溯的方式去计算每次链路的和，整体遍历使用后序遍历。整体性思路，通过后序先找到中间节点，再通过中序，划分左右节点。代码随想录出了提出层序遍历的方法还有一种递归的方法。方法确实是使用前序遍历+递归去处理逻辑。题目：在树的最后一行找到最左边的值。
day18 | 513.找树左下角的值、路径总和、 从中序与后序遍历序列构造二叉树
weixin_45048521的博客
06-12 637
递归的处理方法很妙，我原先想的是返回一个数组，分别记录高度和最左节点的值。后面如果遇到这种需要记录的题目，也可以考虑用这种回溯的思路去做，在递归的外层用变量记录。自己想的步骤→ 先从后续遍历取到末尾的值，再到中序遍历中找到该值，根据该值将其分为左右两个部分。以 后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。可以考虑返回一个数组信息，第一个传的是该分支最左边节点的值，第二个传深度信息，也就是该分支的高度。一直用一个值保存每行的第一个，遍历结束后就放的是最底层的第一个。
Rogerspy#LeetCode-Py-1#0513. 找树左下角的值1
07-25
0513. 找树左下角的值标签：树、深度优先搜索、广度优先搜索、二叉树难度：中等题目大意给定一个二叉树的根节点 root，找出该二叉树 「最底层」的「最左边」节
linzeliang1222#LeetCode#Day16-512.找树左下角的值1
07-25
复杂度分析时间复杂度：$O(N)$，其中 N 为树的结点数量空间复杂度：$O(N)$，其中 N 为树的结点数量思路2（DFS 深度优先搜索）使用 DFS + 回
python-leetcode面试题解之第113题路径总和II-题解.zip
05-06
标题中的“python-leetcode面试题解之第113题路径总和II-题解.zip”指的是一个关于Python编程语言的LeetCode面试题解析资源，具体聚焦于LeetCode的第113题“路径总和II”。这道题目通常出现在程序员的求职面试中，用...
c语言leetcode题解之第113题路径总和II.zip
07-13
c c语言leetcode题解之第113题路径总和II
(第32天) 513、找树左下角的值 112、路径总和 113、路径总和II
m0_73755059的博客
06-11 970
判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum。给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。找出所有符合要求的路径，这就需要在上一题的基础上遍历整颗二叉树，一遇到符合要求的路径就把这条路径加入结果集。给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。严格来说，本题的目的是寻找一条符合要求的路径，而遍历整颗二叉树不是必须的。
LeetCode[中等] 739. 每日温度
Theolulu的博客
09-30 478
给定一个整数数组，表示每天的温度，返回一个数组answer，其中answer[i]是指对于第i天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用0来代替。
【LeetCode】每日一题 2024_10_5 完成旅途的最少时间（二分答案）
最新发布
Locky136的博客
10-05 413
【LeetCode】每日一题 2024_10_5 完成旅途的最少时间（二分答案）
Leetcode—148. 排序链表【中等】
Atticus的博客
10-05 358
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Mopes__的博客
10-01 408
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值