代码随想录-Day17-LetCode|513. 找树左下角的值|112. 路径总和|113. 路径总和 II|106.从后续和中序构建二叉树（补交星期六）

小元祖

已于 2023-10-30 22:46:44 修改

阅读量79

点赞数

文章标签：算法数据结构

于 2023-10-30 22:46:08 首次发布

本文链接：https://blog.csdn.net/qq_63837759/article/details/134129256

版权

513. 找树左下角的值

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

假设二叉树中至少有一个节点。

思路1：使用迭代发，从右到左遍历二叉树，不断迭代结果值，遍历结束之后返回结果值即可


class Solution {
    public int findBottomLeftValue(TreeNode root) {
        //使用 迭代法进行便利
        int result=0;
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            //记录每一层节点个数
            int size=queue.size();
            while(size>0){
                TreeNode node=queue.poll();
                if(node.right!=null) queue.offer(node.right);
                if(node.left!=null) queue.offer(node.left);
                result=node.val;
                size--;
            }
        }
        return result;
    }
}

思路2：使用递归

1，没有返回值，传入参数为根节点，以及deepmax用来记录二叉树的最大深度，在递归过程中不断更迭。定义全局变量保存最后的value。

2，确认遍历顺序为前序遍历，从根节点到叶子节点一层层的找，如果当前为叶子节点，并且当前深度大于最大深度deepmax，我们就将此时叶子节点对应的值交给value，同时更新deepmax最大深度。

3，单层递归逻辑，对非空左子树递归，对非空右子树递归，但是由于我们隐藏了回溯逻辑，所以，当下次递归参数传值的时候，需要手动的将深度加一。

至此，已成艺术。


// 递归法
class Solution {
    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);
    }
}

112. 路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

思路：使用前序进行遍历二叉树，在遍历到当前节点时对目标值减去当前节点值，如果当前遍历到叶子节点，并且目标值为0说明有路径符合，直接返回true。反之返回false，之后执行单层递归逻辑，对非空左子树以及右子树继续遍历返回正确值，最后都不满足返回false。


class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root==null) return false;
        targetSum-=root.val;
        if(root.left==null&&root.right==null&&targetSum==0){
            return true;
        }
        if(root.left==null&&root.right==null&&targetSum!=0){
            return false;   
        }
        if(root.left!=null){
            boolean flag=hasPathSum(root.left,targetSum);
                if(flag) return true;
        }
        if(root.right!=null){
            boolean flag=hasPathSum(root.right,targetSum);
                if(flag) return true;
            
        }
        return false;
    }
}

113. 路径总和 II

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

思路，使用递归，定义两个集合一个存储最终结果，一个存储符合的路径

1，无返回值，传入根节点以及目标值

2，采用前序遍历，将根节点首先加入路径当中，然后将tar做减法，判断当前是否是叶子节点并且tar是否等于0，如果满足，说明是一条符合的路径，将其加入结果集之中，但是注意，不能直接将path加入结果集当中，因为后续需要使用path进行回溯，所以我们拷贝一个path加入即可。

3，遍历左子树和右子树，遍历完之后回溯。即节点向上返回一个，继续找寻新的路径。


class Solution {
    LinkedList<List<Integer>> result=new LinkedList<>();
    LinkedList<Integer> path=new LinkedList<>();
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        pathSums(root,targetSum);
        return result;
    }
    
    void pathSums(TreeNode root,int tar){
        if(root==null) return;
        path.add(root.val);
        tar-=root.val;
        if(tar==0 && root.left==null && root.right==null){
            //将路径进行拷贝之后 加入结果集，
            //路径本身不进入，方便 后续进行回溯 
            result.add(new LinkedList<Integer>(path));
        }
        pathSums(root.left,tar);
        pathSums(root.right,tar);
        //回溯
        path.removeLast();
    }
}

106.从后续和中序构建二叉树

惭愧，没写出来

By 三条直线围墙