二叉树的路径和

题目描述:  给定一个二叉树，找出所有路径中各节点相加总和等于给定 目标值 的路径。

 一个有效的路径，指的是从根节点到叶节点的路径。

思路: 二叉树前序遍历.
1. 若当前节点为空,则直接返回
2. 当前节点不为空,从根节点的路径和加上该节点的值得到根节点到该节点的和
3. 当前节点的左儿子和右儿子为空,判断当前和是否与目标和一致,若一致,则保存路径,然后返回
4. 当前节点存在左儿子或者右儿子,将当前节点加入到路径中,然后分别向左子树和右子树计算,左右都计算完成后,将该节点从路径中除去.

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * Created by parting_soul on 17-6-28.
 * 二叉树路径和
 * <p>
 * 给定一个二叉树，找出所有路径中各节点相加总和等于给定 目标值 的路径。
 * 一个有效的路径，指的是从根节点到叶节点的路径。
 */
public class BinaryTreeAnd {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        TreeNode root = buildTreeByPreOrder(in);
        preOrder(root);
        System.out.println("输入目标值:");
        int target = in.nextInt();
        in.close();
        Solution solution = new Solution();
        solution.binaryTreePathSum(root, target);
        System.out.println(solution.lists);
    }

    /**
     * 输入前序遍历结果建立二叉树,每个字符间有空格,空节点以-1表示
     *
     * @param in
     */
    private static TreeNode buildTreeByPreOrder(Scanner in) {
        int value = in.nextInt();
        TreeNode node = null;
        if (value != -1) {
            node = new TreeNode(value);
            node.left = buildTreeByPreOrder(in);
            node.right = buildTreeByPreOrder(in);
        }
        return node;
    }

    /**
     * 前序遍历
     *
     * @param node
     */
    private static void preOrder(TreeNode node) {
        if (node == null) return;
        System.out.print(node.val);
        preOrder(node.left);
        preOrder(node.right);
    }

    static class Solution {
        ArrayList<List<Integer>> lists = new ArrayList<>();

        /**
         * @param root   the root of binary tree
         * @param target an integer
         * @return all valid paths
         */
        public List<List<Integer>> binaryTreePathSum(TreeNode root, int target) {
            ArrayList<Integer> path = new ArrayList<>();
            preOrderSum(root, path, lists, target, 0);
            return lists;
        }

        private void preOrderSum(TreeNode node, ArrayList<Integer> path, ArrayList<List<Integer>> lists, int target, int sum) {
            if (node == null) {
                return;
            }
//            System.out.println(path);
            sum += node.val;
//            //当前路径和比目标值大,不往下走
//            if (sum > target) return;
            if (node.left == null && node.right == null) {
                if (sum == target) {
                    //lists.add(path);
                    ArrayList<Integer> pathI = new ArrayList<>();
                    for (int i = 0; i < path.size(); i++) {
                        int temp = path.get(i);
                        pathI.add(temp);
                    }
                    lists.add(pathI);
                    pathI.add(node.val);
                }
                return;
            }
            path.add(node.val);
            int len = path.size();
            preOrderSum(node.left, path, lists, target, sum);
            preOrderSum(node.right, path, lists, target, sum);
            path.remove(len - 1);
        }
    }

    static class TreeNode {
        public int val;
        public TreeNode left, right;

        public TreeNode(int val) {
            this.val = val;
            this.left = this.right = null;
        }
    }
}