Day18(二叉树)|513. 找树左下角的值 112. 路径总和 106. 从中序与后序遍历序列构造二叉树

513. 找树左下角的值

• 题目链接：513. 找树左下角的值
• 解题思路：先找最深一层再找最左边节点，递归加回溯，也可以用迭代的方法，层序遍历直接找最后一层第一个节点就可以了
• 主要难点：最底层最左边不一定是整棵树的最左边，应该首先找到最深的层
• 解题步骤：递归三步：
  • 确定参数和返回值：参数：根节点和记录最长深度的值 返回值：不需要
  • 终止条件：遇到叶子节点，更新最大深度
  • 单层逻辑：当遇到最大深度时，递归加回溯
• 解题时间：20+5
• 代码：

/**
 * 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 {
    private int Deep = -1;
    private int value = 0;
    public int findBottomLeftValue(TreeNode root) {
        value=root.val;
        find(root,0);
        return value;
    }
    private void find(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){
            find(root.left,deep+1);
        }
        if(root.right!=null){
            find(root.right,deep+1);
        }
    }
}

112. 路径总和

• 题目链接：112. 路径总和
• 解题思路：递归+回溯，找不到时返回上一个节点，是深度优先的方式
• 主要难点：必须是根节点到叶子节点的一条完成路径，还要判断一下是否到了树的最低
• 解题时间：30+5
• 代码：

/**
 * 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;
        }
        targetSum -= root.val;
        //如果是叶子节点：sum也减小到0则满足，否则不满足
        if(root.left==null&&root.right==null){
            return targetSum==0;
        }
        //左不为空
        if(root.left!=null){
            if(hasPathSum(root.left,targetSum)){//为true则已经找到
                return true;
            }
        }
        //右不为空
        if(root.right!=null){
            if(hasPathSum(root.right,targetSum)){//为true则已经找到
                return true;
            }
        }
        return false;
    }
}

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

• 题目链接：106. 从中序与后序遍历序列构造二叉树
• 解题思路：两个序列互相切分的过程，先从后序拿一个节点，在中序里找到这个节点并分为左右
• 解题时间：20+5
• 代码：30+5（理解）

/**
 * 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 {
    Map<Integer, Integer> map;  // 方便根据数值查找位置
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        map = new HashMap<>();
        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;  // 保存中序左子树个数，用来确定后序数列的个数
        root.left = findNode(inorder, inBegin, rootIndex,
                            postorder, postBegin, postBegin + lenOfLeft);
        root.right = findNode(inorder, rootIndex + 1, inEnd,
                            postorder, postBegin + lenOfLeft, postEnd - 1);

        return root;
    }
}

总结

• 二叉树递归加回溯的问题，首先确定递归的三步走，参数返回值，终止条件和单层逻辑，然后确定怎么回溯，一般是在递归单层并不满足终止条件时要做回溯。