18 第六章 二叉树

学习目标：

• 513.找树左下角的值

• 112. 路径总和 113.路径总和ii

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

---

学习内容：

513.找树左下角的值

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

/**
 * 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 int findBottomLeftValue(TreeNode root) {
        Queue<TreeNode> que = new LinkedList<>();
        int result=0;
        que.offer(root);
        while(!que.isEmpty()){
            int size = que.size();
            
            
            for(int i=0; i<size; i++){
                TreeNode node = que.poll();
                if(i == 0){
                    result = node.val;
                }
                if(node.left != null){
                    que.offer(node.left);
                }
                if(node.right != null){
                    que.offer(node.right);
                }
            }
            }
            return result;
        
    }
}

112. 路径总和

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

/**
 * 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;
        }
        return  traversal(root, targetSum-root.val);
    }
    private boolean traversal(TreeNode node, int count){
        if(node.left == null && node.right == null && count == 0){
            return true;
        }
        if(node.left == null && node.right == null){
            return false;
        }

        if(node.left != null){
            count = count - node.left.val;
            if(traversal(node.left, count) == true){
                return true;
            }
            count = count + node.left.val;
        }
        if(node.right != null){
            count = count - node.right.val;
            if(traversal(node.right, count) == true){
            return true;
            }
            count = count + node.right.val;
        }

        return false;
    }
}

113.路径总和ii

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

/**
 * 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 List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        List<Integer> path = new LinkedList<>();
        traversal(root, targetSum, res, path);
        return res;
    }
    private void traversal(TreeNode node, int count, List<List<Integer>> res, 
    List<Integer> path){
        path.add(node.val);
        if(node.left==null && node.right==null){
            if(count - node.val == 0){
                res.add(new ArrayList<>(path));
            }
            return;
        }

        if(node.left != null){
            traversal(node.left, count-node.val, res, path);
            path.remove(path.size()-1);
        }

        if(node.right != null){
            traversal(node.right, count-node.val, res, path);
            path.remove(path.size()-1);
        }
    }
}

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

根据一棵树的中序遍历与后序遍历构造二叉树。

/**
 * 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.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 node = new TreeNode(inorder[rootIndex]);
        int lenOfLeft = rootIndex - inBegin;

        node.left = findNode(inorder, inBegin, rootIndex, 
        postorder, postBegin, postBegin+lenOfLeft);
        node.right = findNode(inorder, rootIndex+1, inEnd, postorder, 
        postBegin+lenOfLeft, postEnd-1);

        return node;
    }
}

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

根据一棵树的前序遍历与中序遍历构造二叉树。

/**
 * 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[] preorder, int[] inorder) {
        map = new HashMap<>();
        for(int i=0; i<inorder.length; i++){
            map.put(inorder[i], i);
        }
        return traversal(inorder, 0, inorder.length, preorder, 0, preorder.length);
    }

    private TreeNode traversal(int[] inorder, int inBegin, int inEnd, 
    int[] preorder, int preBegin, int preEnd){
        if(inBegin>=inEnd || preBegin>=preEnd){
            return null;
        }

        int rootIndex = map.get(preorder[preBegin]);
        TreeNode node = new TreeNode(inorder[rootIndex]);
        int lenOfLeft = rootIndex - inBegin;
        node.left = traversal(inorder, inBegin, rootIndex, 
        preorder, preBegin+1, preBegin+lenOfLeft+1);
        node.right = traversal(inorder, rootIndex+1, inEnd,
        preorder, preBegin+lenOfLeft+1, preEnd);

        return node;
    }
}