代码随想录算法训练营29期|day 18 任务以及具体安排

•  513.找树左下角的值

• 513.找树左下角的值

  力扣题目链接(opens new window)

  给定一个二叉树，在树的最后一行找到最左边的值。

  示例 1:

  

  示例 2:

  

• //迭代法
  class Solution {
  
      public int findBottomLeftValue(TreeNode root) {
          Queue<TreeNode> queue = new LinkedList<>();
          queue.offer(root);
          int res = 0;
          while (!queue.isEmpty()) {
              int size = queue.size();
              for (int i = 0; i < size; i++) {
                  TreeNode poll = queue.poll();
                  if (i == 0) {
                      res = poll.val;
                  }
                  if (poll.left != null) {
                      queue.offer(poll.left);
                  }
                  if (poll.right != null) {
                      queue.offer(poll.right);
                  }
              }
          }
          return res;
      }
  }

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

• 要注意在Java中队列是Queue，offer是入队，poll是出队，peek是获取队头元素
• 栈是Stack，push是入栈，pop是出栈，peek是获取栈顶元素
•  112. 路径总和  113.路径总和ii
• 

• class Solution {
      public boolean hasPathSum(TreeNode root, int targetSum) {
          if(root == null) return false;
          targetSum -= root.val;
          if(targetSum == 0 && root.left == null && root.right == null) return true;
          if(targetSum != 0 && root.left == null && root.right == null) return false;
          if(root.left != null){
              if(hasPathSum(root.left, targetSum)) return true;
          }
          if(root.right != null){
              if(hasPathSum(root.right, targetSum))  return true; 
          }
  
          return false;
      }
  }

  要知道回溯的过程，知道各个终止条件。

• 

  class Solution {
      List<List<Integer>> result;
      LinkedList<Integer> path;
      public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
          result = new ArrayList<>();
          path = new LinkedList<>();
          traversal(root,targetSum);
          return result;
      }
  
      public void traversal(TreeNode root, int targetSum){
          if(root == null) return;
          path.add(root.val);
          targetSum -= root.val;
          if(root.left == null && root.right == null && targetSum == 0){
              result.add(new LinkedList<>(path));
          }
          traversal(root.left,targetSum);
          traversal(root.right,targetSum);
          path.removeLast();
  
      }
  }

• 要特别注意result没有声明new ArrayList<>()不能path.removeLast();

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

• class Solution {
      public TreeNode buildTree(int[] inorder, int[] postorder) {
          if(postorder.length == 0 || inorder.length == 0)
              return null;
          return buildHelper(inorder, 0, inorder.length, postorder, 0, postorder.length);
      
      }
      private TreeNode buildHelper(int[] inorder, int inorderStart, int inorderEnd, int[] postorder, int postorderStart, int postorderEnd){
          if(postorderStart == postorderEnd)
              return null;
          int rootVal = postorder[postorderEnd - 1];
          TreeNode root = new TreeNode(rootVal);
          int middleIndex;
          for (middleIndex = inorderStart; middleIndex < inorderEnd; middleIndex++){
              if(inorder[middleIndex] == rootVal)
                  break;
          }
  
          int leftInorderStart = inorderStart; 
          int leftInorderEnd = middleIndex;
          int rightInorderStart = middleIndex + 1;
          int rightInorderEnd = inorderEnd;
  
  
          int leftPostorderStart = postorderStart;
          int leftPostorderEnd = postorderStart + (middleIndex - inorderStart);
          int rightPostorderStart = leftPostorderEnd;
          int rightPostorderEnd = postorderEnd - 1;
          root.left = buildHelper(inorder, leftInorderStart, leftInorderEnd,  postorder, leftPostorderStart, leftPostorderEnd);
          root.right = buildHelper(inorder, rightInorderStart, rightInorderEnd, postorder, rightPostorderStart, rightPostorderEnd);
  
          return root;
      }  
  }

  要注意包前不包后！！要注意各个分界点

• 

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