【5.06 代随_18day】 找树左下角的值、路径总和、从中序与后序遍历序列构造二叉树

---

找树左下角的值

力扣连接：513. 找树左下角的值（中等）

1.递归的方法

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

递归的图解步骤

暂无

递归代码

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

2.迭代的方法

本题使用层序遍历再合适不过了，比递归要好理解得多！

class Solution {
    public int findBottomLeftValue(TreeNode root) {
        int result = 0;
        Deque<TreeNode> que = new LinkedList<>();
        que.add(root);

        while(!que.isEmpty()){
            int size = que.size();
            int sizeLen = que.size();
            
            while(size>0){
                TreeNode node = que.poll();

                if(size==sizeLen){
                    result = node.val;
                }
                
                if(node.left!=null)que.add(node.left);
                if(node.right!=null)que.add(node.right);
                size--;
            }
        }

        return result;
    }
}

---

---

路径总和

力扣连接：112. 路径总和（简单）

1.递归的方法

递归的图解步骤

递归代码

class Solution {

    public boolean hasPathSum(TreeNode root, int targetSum) {
        if (root==null) return false;
        if (root.left == null && root.right == null) return root.val == targetSum;
        return rootSum(root, targetSum-root.val);

    }

    public boolean rootSum(TreeNode root, int count){
        if(root==null) return false;
        if(root.left==null&&root.right==null&&count==0) return true;
        if(root.left==null&&root.right==null) return false;

        if(root.left!=null){
            count -= root.left.val;
            if(rootSum(root.left,count)) return true;
            count += root.left.val;
        }

        if(root.right!=null){
            count -= root.right.val;
            if(rootSum(root.right,count)) return true;
            count += root.right.val;
        }

        return false;
    }
}

---

---

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

力扣连接：106. 从中序与后序遍历序列构造二叉树（中等）

以 后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。

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

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

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

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

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

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

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

图解步骤

代码

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

---

---