代码随想录算法训练营第天十六天丨二叉树part04

叫一只啦啦

已于 2023-10-11 10:12:09 修改

阅读量119

点赞数

分类专栏：代码随想录算法训练营文章标签：算法数据结构 java

于 2023-10-10 20:42:12 首次发布

本文链接：https://blog.csdn.net/qq_67786627/article/details/133734190

版权

代码随想录算法训练营专栏收录该内容

51 篇文章 4 订阅

订阅专栏

文档讲解：代码随想录

状态：已完成

513.找树左下角的值

思路

递归

分析一下题目：在树的最后一行找到最左边的值。

首先要是最后一行，然后是最左边的值。

如果使用递归法，如何判断是最后一行呢，其实就是深度最大的叶子节点一定是最后一行。

所以要找深度最大的叶子节点。

那么如何找最左边的呢？可以使用前序遍历（当然中序，后序都可以，因为本题没有中间节点的处理逻辑，只要左优先就行），保证优先左边搜索【重点，因为优先搜索左边，当叶子节点不只有一个的时候，他会先搜索左边，将深度及值记录下来，之后再遇到相同深度的叶子就直接跳过了】，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。

递归三部曲：

1.确定递归函数的参数和返回值

参数必须有要遍历的树的根节点，还有就是一个int型的变量用来记录最长深度。这里就不需要返回值了，所以递归函数的返回类型为void。

本题还需要类里的两个全局变量，maxLen用来记录最大深度，result记录最大深度最左节点的数值。

代码如下：

int maxDepth = Integer.MIN_VALUE;
int result = Integer.MIN_VALUE;
void findLeftVal(TreeNode node ,int depth)

2.确定终止条件

当遇到叶子节点的时候，就需要统计一下最大的深度了，所以需要遇到叶子节点来更新最大深度。

代码如下：

//终止条件
if (node.left == null && node.right == null){
    if (depth > maxDepth){
        maxDepth = depth;
        esult = node.val;
    }
    return ;
}

3.确定单层递归的逻辑

在找最大深度的时候，递归的过程中依然要使用回溯，代码如下：

                    // 中
 //左
if (node.left != null){
    depth++;
    findLeftVal(node.left,depth);
    depth--;
}
//右
if (node.right != null){
    depth++;
    findLeftVal(node.right,depth);
    depth--;
}
return;

完整代码如下：

class Solution {
    int maxDepth = Integer.MIN_VALUE;
    int result = Integer.MIN_VALUE;
    public int findBottomLeftValue(TreeNode root) {
        if (root == null){
            return 0;
        }
        findLeftVal(root,1);
        return result;
    }
    void findLeftVal(TreeNode node ,int depth){
        //终止条件
        if (node.left == null && node.right == null){
            if (depth > maxDepth){
                maxDepth = depth;
                result = node.val;
            }
            return ;
        }
        //左
        if (node.left != null){
            depth++;
            findLeftVal(node.left,depth);
            depth--;
        }
        //右
        if (node.right != null){
            depth++;
            findLeftVal(node.right,depth);
            depth--;
        }
    }
}

112. 路径总和

思路

递归

可以使用深度优先遍历的方式（本题前中后序都可以，无所谓，因为中节点也没有处理逻辑）来遍历二叉树

1.确定递归函数的参数和返回类型

参数：需要二叉树的根节点，还需要一个计数器，这个计数器用来计算二叉树的一条边之和是否正好是目标和，计数器为int型。

再来看返回值，递归函数什么时候需要返回值？什么时候不需要返回值？这里总结如下三点：

如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。（这种情况就是本文下半部分介绍的113.路径总和ii）
如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。（这种情况我们在236. 二叉树的最近公共祖先 (opens new window)中介绍）
如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。（本题的情况）

而本题我们要找一条符合条件的路径，所以递归函数需要返回值，及时返回，那么返回类型是什么呢？

如图所示：

112.路径总和

图中可以看出，遍历的路线，并不要遍历整棵树，所以递归函数需要返回值，可以用bool类型表示。

中可以看出，遍历的路线，并不要遍历整棵树，所以递归函数需要返回值，可以用bool类型表示。

所以代码如下：

boolean findTargetNum(TreeNode node,int sum,int targetSum)   // 注意函数的返回类型

2.确定终止条件

首先计数器如何统计这一条路径的和呢？

我选择去累加然后判断是否等于目标和，if叶子节点中出现 sum == targetNum 就返回true

递归终止条件代码如下：

// 遇到叶子节点而没有找到合适的边，直接返回
 if (node.left == null && node.right == null){
            return sum == targetSum;
        }

3.确定单层递归的逻辑

因为终止条件是判断叶子节点，所以递归的过程中就不要让空节点进入递归了。

递归函数是有返回值的，如果递归函数返回true，说明找到了合适的路径，应该立刻返回。

代码如下：

if (node.left != null){ //左
   // 遇到叶子节点返回true，则直接返回true
   // 注意这里有回溯的逻辑
   sum += node.left.val;
   boolean boolLfet = findTargetNum(node.left, sum, targetSum);
   if (boolLfet){
      return true;
   }
   sum -= node.left.val;
}
if (node.right != null){//右
   // 遇到叶子节点返回true，则直接返回true
   // 注意这里有回溯的逻辑
   sum += node.right.val;
   boolean boolRight = findTargetNum(node.right, sum, targetSum);
   if (boolRight){
      return true;
   }
       sum -= node.right.val;
}
return false;

以上代码中是包含着回溯的.

代码如下：

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if (root == null){return false;}
        return findTargetNum(root,root.val, targetSum);
    }
    boolean findTargetNum(TreeNode node,int sum,int targetSum){
        if (node.left == null && node.right == null){
            return sum == targetSum;
        }
        if (node.left != null){ //左
            // 遇到叶子节点返回true，则直接返回true
            // 注意这里有回溯的逻辑
            sum += node.left.val;
            boolean boolLfet = findTargetNum(node.left, sum, targetSum);
            if (boolLfet){
                return true;
            }
            sum -= node.left.val;
        }
        if (node.right != null){//右
            // 遇到叶子节点返回true，则直接返回true
            // 注意这里有回溯的逻辑
            sum += node.right.val;
            boolean boolRight = findTargetNum(node.right, sum, targetSum);
            if (boolRight){
                return true;
            }
            sum -= node.right.val;
        }
        return false;
    }
}

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

思路

首先回忆一下如何根据两个顺序构造一个唯一的二叉树，相信理论知识大家应该都清楚，就是以后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。

如果让我们肉眼看两个序列，画一棵二叉树的话，应该分分钟都可以画出来。

流程如图：

那么代码应该怎么写呢？

说到一层一层切割，就应该想到了递归。

来看一下一共分几步：

第一步：如果数组大小为零的话，说明是空节点了。
第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
第四步：切割中序数组，切成中序左数组和中序右数组（顺序别搞反了，一定是先切中序数组）
第五步：切割后序数组，切成后序左数组和后序右数组
第六步：递归处理左区间和右区间

其中，

难点就是如何切割，以及边界值找不好很容易乱套。

此时应该注意确定切割的标准，是左闭右开，还有左开右闭，还是左闭右闭，这个就是不变量，要在递归中保持这个不变量。

在切割的过程中会产生四个区间，把握不好不变量的话，一会左闭右开，一会左闭右闭，必然乱套！

卡哥在数组：每次遇到二分法，都是一看就会，一写就废 (opens new window)和数组：这个循环可以转懵很多人！ (opens new window)中都强调过循环不变量的重要性，在二分查找以及螺旋矩阵的求解中，坚持循环不变量非常重要，本题也是。

首先要切割中序数组，为什么先切割中序数组呢？

切割点在后序数组的最后一个元素，就是用这个元素来切割中序数组的，所以必要先切割中序数组。

中序数组相对比较好切，找到切割点（后序数组的最后一个元素）在中序数组的位置，然后切割，如下代码中我坚持左闭右闭的原则：

整体代码如下

class Solution {
    //存放中序遍历数组，方便之后快速查找 值 的索引位置
    Map<Integer,Integer> map;
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        map = new HashMap<>();
        for (int i = 0; i < inorder.length; i++) {
            map.put(inorder[i],i);
        }
        return structureTree(inorder,0, inorder.length-1,postorder,0, postorder.length-1);//左闭右闭
    }
    TreeNode structureTree(int[] inorder,int inorderStart,int inorderEnd, int[] postorder,int postorderStart,int postorderEnd){
        //确定边界条件，左闭右闭
        if (inorderStart > inorderEnd || postorderStart > postorderEnd){//如果不满足左闭右闭，说明没有元素，返回空
            return null;
        }
        //获得根节点的值,创建节点
        int val = postorder[postorderEnd];
        //获得中序遍历中 值为 val 的索引
        int index = map.get(val);
        TreeNode node = new TreeNode(val);//构造节点
        // 保存中序左子树的个数，用来确定后续数组的个数
        int lenOfLeft = index - 1 - inorderStart;
        //左
        node.left = structureTree(inorder,inorderStart,index-1
                ,postorder,postorderStart,lenOfLeft + postorderStart);
        //右
        node.right = structureTree(inorder,index+1,inorder.length -1
                ,postorder,lenOfLeft + postorderStart + 1,postorderEnd - 1);
        return node;
    }
}