day15|513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树、105.从前序与中序遍历序列构造二叉树

奈川直子

已于 2023-01-17 17:15:18 修改

阅读量458

点赞数 1

分类专栏： # 算法练习文章标签：算法数据结构 java leetcode 深度优先

于 2023-01-15 23:17:14 首次发布

本文链接：https://blog.csdn.net/weixin_52767345/article/details/128698382

版权

算法练习专栏收录该内容

42 篇文章 0 订阅

订阅专栏

513.找树左下角的值

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

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

示例 1:

输入: root = [2,1,3]

输出: 1

示例 2:

输入: [1,2,3,4,null,5,6,null,null,7]

输出: 7

问题分析：

递归法：找到最底层的左叶子，递归和回溯，左遍历必须在前，无论多深，左先遍历，一定最先找到左节点的值。中的处理逻辑为空，所以前中后遍历都可以，因为左遍历一直在右遍历前。

其实用迭代法更简单，但我就不，有空更新

class Solution {
    int maxdep=Integer.MIN_VALUE;
    int result;//存放最后的结果
    public int findBottomLeftValue(TreeNode root) {
        result=root.val;//千万不能忘
        traversal(root,maxdep);
        return result;
    }
    public void traversal(TreeNode node,int depth){
        if (node.left==null&&node.right==null) {//终止条件
            if (depth>maxdep){
                maxdep=depth;
                result=node.val;
            }
        }
        
        //单层逻辑
        if (node.left!=null){//左
            depth++;
            traversal(node.left,depth);//递归
            depth--;//回溯，让深度复原
        }
        if (node.right!=null){//左
            depth++;
            traversal(node.right,depth);
            depth--;//回溯，让深度复原
        }
    }
}

112. 路径总和

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

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

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22

输出：true

解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

输入：root = [1,2,3], targetSum = 5

输出：false

解释：树中存在两条根节点到叶子节点的路径：

(1 --> 2): 和为 3

(1 --> 3): 和为 4

不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0

输出：false

解释：由于树是空的，所以不存在根节点到叶子节点的路径。

问题描述：

中节点无处理逻辑，所以前中后遍历顺序都可以。

1、确定递归函数的参数和返回类型参数：需要二叉树的根节点，还需要一个计数器，这个计数器用来计算二叉树的一条边之和是否正好是目标和，计数器为int型。，计数器初始值为targetSum，每走到一个节点，计数器就减去节点的值

再来看返回值，总结如下三点：

如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。（113.路径总和ii）
如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。（236.二叉树的最近公共祖先）
如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。（本题）

2、确定终止条件如果为叶子节点，且计数器为0，就return true 如果是叶子节点，计数器不为零，就return false

3、确定单层递归的逻辑因为终止条件是判断叶子节点，所以递归的过程中就不要让空节点进入递归了。递归函数是有返回值的，如果递归函数返回true，说明找到了合适的路径，应该立刻返回。如果路径有误，则要回溯。

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
       if (root==null) return false;
        targetSum=targetSum-root.val;
       return traversal(root,targetSum);


    }

    public boolean traversal(TreeNode root,int targetSum){
        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){//左
            targetSum=targetSum-root.left.val;
            if (traversal(root.left,targetSum)){//告知上层递归结果，及时返回
                return true;
            }
            targetSum=targetSum+root.left.val;//回溯
        }

        if (root.right!=null){//右
            targetSum=targetSum-root.right.val;
            if (traversal(root.right,targetSum)){//告知上层递归结果
                return true;
            }
            targetSum=targetSum+root.right.val;//回溯
        }

        return false;//若一直没返回true，最后返回flase
    }
}

113.路径总和ii

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

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22

输出：[[5,4,11,2],[5,8,4,5]]

示例 2：

输入：root = [1,2,3], targetSum = 5

输出：[]

示例 3：

输入：root = [1,2], targetSum = 0

输出：[]

问题描述：

找到所有路径，所以递归函数不要返回值，思路如上题

class Solution {

    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<Integer> paths=new ArrayList<>();
        List<List<Integer>> result=new ArrayList<List<Integer>>();
        if (root==null) return result;
        traversal(root,targetSum,paths,result);
        return result;


    }
    public void traversal(TreeNode node,int count,List<Integer> paths,List<List<Integer>> result){
        paths.add(node.val);
        if (node.left==null&&node.right==null) {
           if (count-node.val==0){
               result.add(new ArrayList<>(paths));
           }
        }

        if (node.left!=null){
            traversal(node.left,count-node.val,paths,result);
            paths.remove(paths.size()-1);//回溯
        }
        if (node.right!=null){
            traversal(node.right,count-node.val,paths,result);
            paths.remove(paths.size()-1);//回溯
        }

    }
}

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

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗二叉树。

示例 1:

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]

输出：[3,9,20,null,null,15,7]

示例 2:

输入：inorder = [-1], postorder = [-1]

输出：[-1]

问题描述：

第一步：如果数组大小为零的话，说明是空节点了。

第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。

第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点

第四步：切割中序数组，切成中序左数组和中序右数组（顺序别搞反了，一定是先切中序数组）

第五步：切割后序数组，切成后序左数组和后序右数组

第六步：递归处理左区间和右区间

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        if (inorder.length==0||postorder.length==0) return null;
        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 (postEnd==postBegin) return null;
        if (inBegin==inEnd) return null;//不能写成if (postBegin==inEnd)
        int rootValue=postorder[postEnd-1];//取后序遍历最后一个元素为节点元素

        TreeNode root=new TreeNode(rootValue);//构建新二叉树
        if (postEnd-postBegin==1) return root;//如果后序遍历只有一个节点，那就是根节点
        int index;
        for (index=inBegin;index<inEnd;index++){//寻找中序数组位置，做切割点
            if (inorder[index]==rootValue) break;
        }
        //切中序数组
        //左中序，左闭右开[leftInorderBegin,leftInorderEnd)
        int leftInorderBegin=inBegin;
        int leftInorderEnd=index;
        //右中序，左闭右开[rightInorderBegin,rightInorderEnd)
        int rightInorderBegin=index+1;
        int rightInorderEnd=inEnd;//inEnd已赋值inorder.length
        //切后序数组
        //左后序，左闭右开
        int leftPostorderBegin=postBegin;
        int leftpostorderEnd=postBegin+(index-inBegin);//通过中序遍历可知左子树右区间
        //右后序，左闭右开
        int rightPostorderBegin=postBegin+(index-inBegin);
        int rightPostorderEnd=postEnd-1;//postEnd已赋值postorder.length，且在最后的根节点排除，右开

        root.left=findNode(inorder,leftInorderBegin,leftInorderEnd,postorder,leftPostorderBegin,leftpostorderEnd);
        root.right=findNode(inorder,rightInorderBegin,rightInorderEnd,postorder,rightPostorderBegin,rightPostorderEnd);
        return root;
    }
}

这题ex吐了，卡了一晚上

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

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

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22

输出：true

解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

输入：root = [1,2,3], targetSum = 5

输出：false

解释：树中存在两条根节点到叶子节点的路径： (1 --> 2): 和为 3 (1 --> 3): 和为 4 不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0

输出：false

解释：由于树是空的，所以不存在根节点到叶子节点的路径。

问题分析：

第一步：如果数组大小为零的话，说明是空节点了。

第二步：如果不为空，那么取前序数组第一个元素作为节点元素。

第三步：找到前序数组第一个元素在中序数组的位置，作为切割点

第四步：切割中序数组，切成中序左数组和中序右数组（顺序别搞反了，一定是先切中序数组）

第五步：切割前序数组，切成前序左数组和前序右数组

第六步：递归处理左区间和右区间

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder.length==0) return null;//可有可无
        return  traversal(preorder,0, preorder.length, inorder,0,inorder.length);

    }
    public TreeNode traversal(int[] preorder,int preBegin,int preEnd,int[] inorder,int inBegin,int inEnd){
        if (preBegin==preEnd) return null;

        //第二步
        int rootVal=preorder[preBegin];
        //第三步
        int index;
        for (index=inBegin;index<inEnd;index++){
            if (inorder[index]==rootVal)  break;//index记住此时位置
        }
        TreeNode root=new TreeNode(rootVal);
        //第四步 切中序数组
        int leftinOrderBegin=inBegin;
        int leftinOrderEnd=index;

        int rightinOrderBegin=index+1;
        int rightinOrderEnd=inEnd;

        //第五步 切前序数组
        int leftpreOrderBegin=preBegin+1;
        int leftpreOrderEnd=preBegin+1+(index-inBegin);

        int rightpreOrderBegin=preBegin+1+(index-inBegin);
        int rightpreOrderEnd=preEnd;

        //第六步
        root.left=traversal(preorder,leftpreOrderBegin,leftpreOrderEnd,inorder,leftinOrderBegin,leftinOrderEnd);
        root.right=traversal(preorder,rightpreOrderBegin,rightpreOrderEnd,inorder,rightinOrderBegin,rightinOrderEnd);

        return root;

    }
}