算法随想录算法训练营第十六天| 找树左下角的值 路径总和 路径总和ii 从中序与后序遍历序列构造二叉树 从前序与中序遍历序列构造二叉树

目录

找树左下角的值

路径总和  

路径总和ii

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

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

---

找树左下角的值

文章讲解：代码随想录

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

---

路径总和  

 文章讲解：代码随想录

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

---

路径总和ii

文章讲解：代码随想录

class Solution {
    List<List<Integer>> lists = new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        if (root == null)
            return lists;
        List<Integer> list = new ArrayList<>();
        dfs(list, root, targetSum);
        return lists;
    }

    public void dfs(List<Integer> list, TreeNode node, int target) {
        list.add(node.val);
        if (node.left == null && node.right == null) {
            if (target == node.val) {
              lists.add(new ArrayList<>(list));
            }
            return;
        }
        if (node.left != null){
            dfs(list,node.left,target-node.val);
            list.remove(list.size()-1);
        }
        if (node.right != null) {
            dfs(list,node.right,target-node.val);
            list.remove(list.size()-1);
        }
    }
}

---

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

文章讲解：代码随想录

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        if (inorder.length == 0 && postorder.length == 0)
            return null;
        return traversal(inorder, 0, inorder.length, postorder, 0, postorder.length);
    }
    public TreeNode traversal(int[] inorder, int inorderBegin, int inorderEnd, int[] postorder, int postorderBegin, int postorderEnd) {//inorder是中序遍历   postorder是后序遍历
        if (postorderBegin == postorderEnd) return null;
        int rootValue = postorder[postorderEnd - 1];
        TreeNode root = new TreeNode(rootValue);
       if (postorderEnd - postorderBegin == 1)
            return root;
        int delimiterIndex = 0;
        for (delimiterIndex = 0; delimiterIndex < inorder.length; delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue)
                break;
        }
        //切割中序数组
        //切割的左边中序区间[inorderBegin，delimiterIndex)
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        //切割的右边的中序区间[delimiterIndex,inorderEnd)
        int rightInOrderBegin = delimiterIndex + 1;
        int rightInOrderEnd = inorderEnd;

        //切割后序数组
        //左边的后序区间[)
        int leftPostorderBegin = postorderBegin;
        int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin;
        //右边的后序区间[rightPostorderBegin,postorderEden)
        int rightPostorderBegin = postorderBegin + delimiterIndex - inorderBegin;
        int rightPostorderEden = postorderEnd - 1;
        root.left = traversal(inorder, leftInorderBegin, leftInorderEnd, postorder, leftPostorderBegin, leftPostorderEnd);
        root.right = traversal(inorder, rightInOrderBegin, rightInOrderEnd, postorder, rightPostorderBegin, rightPostorderEden);
        return root;
    }
}

太复杂了，这题我不会呀！！！

---

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

文章讲解：代码随想录

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
  if (inorder.length == 0)
            return null;
        return traversalHead(preorder, 0, preorder.length, inorder, 0, inorder.length);
    }
      public static TreeNode traversalHead(int[] preorder, int leftPreOrderBegin, int leftPreOrderEnd, int[] inorder, int rightInOrderBegin, int rightInOrderEnd) {
        if (rightInOrderBegin == rightInOrderEnd)
            return null;
        int rootValue = preorder[leftPreOrderBegin];
        TreeNode root = new TreeNode(rootValue);
        if (leftPreOrderEnd - leftPreOrderBegin == 1)
            return root;
        int limitIndex = 0;
        for (limitIndex = 0; limitIndex < inorder.length; limitIndex++) {
            if (inorder[limitIndex] == rootValue)
                break;
        }
        //切割中序遍历
        //中序遍历的左边[leftInBegin,leftInEnd)
        int leftInBegin = rightInOrderBegin;
        int leftInEnd = limitIndex;
        //中序遍历的右边[rightInBegin,leftInEnd)
        int rightInBegin = limitIndex + 1;
        int rightInEnd = rightInOrderEnd;

        //切割前序遍历
        //前序遍历的左边[leftPreBegin,leftPreEnd)
        int leftPreBegin = leftPreOrderBegin + 1;
        int leftPreEnd = leftPreOrderBegin + leftInEnd - leftInBegin + 1;
        //前序遍历的右边[rightPreBegin,rightPreEnd)
        int rightPreBegin = leftPreEnd;
        int rightPreEnd = leftPreOrderEnd;
        root.left = traversalHead(preorder, leftPreBegin, leftPreEnd, inorder, leftInBegin, leftInEnd);
        root.right = traversalHead(preorder, rightPreBegin, rightPreEnd, inorder, rightInBegin, rightInEnd);
        return root;
    }
}