每日一道Leetcode——路径总和 II

题目：

我的解法：
从根节点开始，向下迭代寻找到叶子结点的路径，每个路径存为一个List，当前路径随结点一起向下迭代，直到结点的左右结点均为null，则计算该路径对应List所有元素的和，如果等于sum，添加到结果中。
但是每次迭代都要创建新的List，空间和时间复杂度太高。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<List<Integer>> result = new ArrayList<List<Integer>>();
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        if (root==null){
            return result;
        }
        List<Integer> list = new ArrayList<Integer>();
        getPath(root, sum, list);
        return result;
    }

    public void getPath(TreeNode t, int sum, List<Integer> list){
        if (t.left==null && t.right==null){
            List<Integer> final_list = new ArrayList<Integer>();
            for(Integer val: list){
                final_list.add(val);
            }
            final_list.add(t.val);
            // 计算list的和
            int sum_val = 0;
            for(Integer val: final_list){
                sum_val = sum_val + val;
            }
            if(sum_val == sum){
                result.add(final_list);
            }
        }
        list.add(t.val);
        List<Integer> left_list = new ArrayList<Integer>();
        for(Integer val: list){
                left_list.add(val);
            }
        List<Integer> right_list = new ArrayList<Integer>();
        for(Integer val: list){
                right_list.add(val);
            }
        if (t.left!=null){
            getPath(t.left, sum, left_list);
        }
        if (t.right!=null){
            getPath(t.right, sum, right_list);
        }
    }
}

官方题解一：深度优先搜索
本解法与我上面的思路相同，但是在存储路径的方式上进行了优化，只使用一个list存储，每次迭代先加入当前节点，然后迭代左右子结点，最后再取出当前节点，比我的方法节省了空间复杂度。

class Solution {
    List<List<Integer>> ret = new LinkedList<List<Integer>>();
    Deque<Integer> path = new LinkedList<Integer>();

    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        dfs(root, sum);
        return ret;
    }

    public void dfs(TreeNode root, int sum) {
        if (root == null) {
            return;
        }
        path.offerLast(root.val);
        sum -= root.val;
        if (root.left == null && root.right == null && sum == 0) {
            ret.add(new LinkedList<Integer>(path));
        }
        dfs(root.left, sum);
        dfs(root.right, sum);
        path.pollLast();
    }
}

官方题解二：广度优先搜索

class Solution {
    List<List<Integer>> ret = new LinkedList<List<Integer>>();
    Map<TreeNode, TreeNode> map = new HashMap<TreeNode, TreeNode>();

    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        if (root == null) {
            return ret;
        }

        Queue<TreeNode> queueNode = new LinkedList<TreeNode>();
        Queue<Integer> queueSum = new LinkedList<Integer>();
        queueNode.offer(root);
        queueSum.offer(0);

        while (!queueNode.isEmpty()) {
            TreeNode node = queueNode.poll();
            int rec = queueSum.poll() + node.val;

            if (node.left == null && node.right == null) {
                if (rec == sum) {
                    getPath(node);
                }
            } else {
                if (node.left != null) {
                    map.put(node.left, node);
                    queueNode.offer(node.left);
                    queueSum.offer(rec);
                }
                if (node.right != null) {
                    map.put(node.right, node);
                    queueNode.offer(node.right);
                    queueSum.offer(rec);
                }
            }
        }

        return ret;
    }

    public void getPath(TreeNode node) {
        List<Integer> temp = new LinkedList<Integer>();
        while (node != null) {
            temp.add(node.val);
            node = map.get(node);
        }
        Collections.reverse(temp);
        ret.add(new LinkedList<Integer>(temp));
    }
}