Day18｜二叉树part05：513.找树左下角的值、112. 路径总和 113.路径总和ii、 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树-CSDN博客

本文链接：https://blog.csdn.net/weixin_43303286/article/details/136977112

放*的是重点题目

513. *找树左下角的值（有回溯）

层序遍历，在for循环每次的第一次更新res的值：

class Solution {
    private Deque<TreeNode> queue = new LinkedList<>();
    public int findBottomLeftValue(TreeNode root) {
        int res = 0;
        queue.add(root);
        while(!queue.isEmpty()){
            int len = queue.size();
            for (int i = 0; i < len; i++) {
                TreeNode p = queue.poll();
                if(i == 0){
                    res = p.val;
                }

                if(p.left != null){
                    queue.add(p.left);
                }
                if(p.right != null){
                    queue.add(p.right);
                }
            }

        }
        return res;
    }
}

递归法，重点在于怎么找到最后一层的最左边的节点，方法是借助最大深度，当深度不更新了，就到最大了，此时更新val的值

    class Solution {
//        public int test() {
//            TreeNode root = new TreeNode(1);
//            root.left = new TreeNode(2);
//            root.right = new TreeNode(3);
//            root.left.left = new TreeNode(4);
//            root.right.left = new TreeNode(5);
//            root.right.right = new TreeNode(6);
//            root.right.left.right = new TreeNode(7);
//            return findBottomLeftValue(root);
//        }

        private int res = 0;
        private int depth = 0;
        private int maxDepth = Integer.MIN_VALUE;

        //思路：
        private void traversal(TreeNode node) {
            if (node == null) {
                return;
            }
            if (node.left == null && node.right == null) {
                if (depth > maxDepth) {
                    maxDepth = depth;
                    res = node.val;
                }
                return;
            }
            if (node.left != null) {
                depth++;
                traversal(node.left);
                depth--;
            }
            if (node.right != null) {
                depth++;
                traversal(node.right);
                depth--;
            }

        }

        public int findBottomLeftValue(TreeNode root) {
            traversal(root);
            return res;
        }
    }

112. *路径总和

还是递归 + 回溯
用TargetSum来减，就不用声明新的sum变量了。

class Solution {
        public boolean test() {
            TreeNode root = new TreeNode(5);
            root.left = new TreeNode(4);
            root.right = new TreeNode(8);
            root.left.left = new TreeNode(11);
            root.left.left.left = new TreeNode(7);
            root.left.left.right = new TreeNode(2);
            root.right.left = new TreeNode(13);
            root.right.right = new TreeNode(4);
            root.right.right.right = new TreeNode(1);
            return hasPathSum(root, 22);
        }

        private boolean res = false;

        private void traversal(TreeNode node, int targetSum) {
//        if(node == null){
//            return ;
//        }
            if (node.left == null && node.right == null) {
                if (targetSum == node.val) {
                    res = true;
                }
                return;
            }
            if (node.left != null) {
                targetSum -= node.val;
                traversal(node.left, targetSum);
                targetSum += node.val;
            }
            if (node.right != null) {
                targetSum -= node.val;
                traversal(node.right, targetSum);
                targetSum += node.val;
            }

        }

        public boolean hasPathSum(TreeNode root, int targetSum) {
            if(root == null){
                return false;
            }
            traversal(root, targetSum);
            return res;
        }
    }

113. 路径总和II

跟上题思路差不多，就是添加了结果数组，需要一起回溯：

class Solution {
        private List<List<Integer>> resList = new ArrayList<>();
        private List<Integer> res = new ArrayList<>();

        private void traversal(TreeNode node, int targetSum) {
            if (node.left == null && node.right == null) {
                if (targetSum == node.val) {
                    res.add(node.val);
                    resList.add(new ArrayList<>(res));
                    res.remove(res.size() - 1);
//                    res.clear();
                }
                return;
            }
            if (node.left != null) {
                targetSum -= node.val;
                res.add(node.val);
                traversal(node.left, targetSum);
                res.remove(res.size() - 1);
                targetSum += node.val;
            }
            if (node.right != null) {
                targetSum -= node.val;
                res.add(node.val);
                traversal(node.right, targetSum);
                res.remove(res.size() - 1);
                targetSum += node.val;
            }

        }

        public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
            if(root == null){
                return resList;
            }
            traversal(root, targetSum);
            return resList;
        }
    }

这里注意把res添加到resList中时要用resList.add(new ArrayList<>(res));而不是resList.add(res)：

你将 res 添加到 resList 中。然而，这里有一个问题，那就是在Java中，当你将一个列表添加到另一个列表时，实际上添加的是引用，而不是值。这意味着，当你修改 res 时，已经添加到 resList 中的列表也会被修改。

437. ***路径总和III

这题很特殊！因为他要去路径不是非要从根节点开始！任何节点都可以，因为要在朱函数pathSum中就要用递归，为每一个节点都作为root遍历一次：

class Solution {
        public void test() {
            TreeNode root = new TreeNode(10);
            root.left = new TreeNode(5);
            root.right = new TreeNode(-3);
            root.left.left = new TreeNode(3);
            root.left.right = new TreeNode(2);
            root.right.right = new TreeNode(11);
            root.left.left.left = new TreeNode(3);
            root.left.left.right = new TreeNode(-2);
            root.left.right.right = new TreeNode(1);
            // Call your function here with root as paramete
            traversal(root, 8);
        }

        private int res = 0;

        private void traversal(TreeNode node, long targetSum) {
            if (node == null) {
                return;
            }
            if (targetSum == node.val) {
                res++;
            }
            if (node.left != null) {
                targetSum -= node.val;
                traversal(node.left, targetSum);
                targetSum += node.val;
            }
            if (node.right != null) {
                targetSum -= node.val;
                traversal(node.right, targetSum);
                targetSum += node.val;
            }

        }

        public int pathSum(TreeNode root, long targetSum) {
            if(root == null){
                return res;
            }
            traversal(root, targetSum);
            pathSum(root.left, targetSum);
            pathSum(root.right, targetSum);

            return res;
        }
    }

106.***从中序与后序遍历序列构造二叉树（常考题型）

首先回忆一下如何根据两个顺序构造一个唯一的二叉树，就是以后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。所以还原二叉树必须要有中序遍历的序列（左根右）
一共分6步：

一共分几步：

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

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

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

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

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

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

代码：

class Solution {
        private Map<Integer, Integer> map = new HashMap<>();

        public TreeNode traversal(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 = traversal(inorder, inBegin, rootIndex,
                    postorder, postBegin, postBegin + lenOfLeft);
            root.right = traversal(inorder, rootIndex + 1, inEnd,
                    postorder, postBegin + lenOfLeft, postEnd - 1);

            return root;
        }

        public TreeNode buildTree(int[] inorder, int[] postorder) {
            //首先构建{value,index}字典
            for (int i = 0; i < inorder.length; i++) {
                map.put(inorder[i], i);
            }
            return traversal(inorder, 0, inorder.length, postorder, 0, postorder.length);
        }
    }

这里注意java数组可操作性比较少，要手动带索引，而且用hashtable存快速查索引。

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

class Solution {
      Map<Integer, Integer> map;

      public TreeNode buildTree(int[] preorder, int[] inorder) {
          map = new HashMap<>();
          for (int i = 0; i < inorder.length; i++) { // 用map保存中序序列的数值对应位置
              map.put(inorder[i], i);
          }

          return findNode(preorder, 0, preorder.length, inorder, 0, inorder.length);  // 前闭后开
      }

      public TreeNode findNode(int[] preorder, int preBegin, int preEnd, int[] inorder, int inBegin, int inEnd) {
          // 参数里的范围都是前闭后开
          if (preBegin >= preEnd || inBegin >= inEnd) {  // 不满足左闭右开，说明没有元素，返回空树
              return null;
          }
          int rootIndex = map.get(preorder[preBegin]);  // 找到前序遍历的第一个元素在中序遍历中的位置
          TreeNode root = new TreeNode(inorder[rootIndex]);  // 构造结点
          int lenOfLeft = rootIndex - inBegin;  // 保存中序左子树个数，用来确定前序数列的个数
          root.left = findNode(preorder, preBegin + 1, preBegin + lenOfLeft + 1,
                  inorder, inBegin, rootIndex);
          root.right = findNode(preorder, preBegin + lenOfLeft + 1, preEnd,
                  inorder, rootIndex + 1, inEnd);

          return root;
      }
  }