LeetCode103|路径总和II

示例:
给定如下二叉树，以及目标和 sum = 22，

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \    / \
        7    2  5   1
返回:

[
   [5,4,11,2],
   [5,8,4,5]
]

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class PathSumTest {
    public static void main(String[] args) {
        TreeNode t1 = new TreeNode(5);
        TreeNode t2 = new TreeNode(4);
        TreeNode t3 = new TreeNode(8);
        TreeNode t4 = new TreeNode(11);
        TreeNode t5 = new TreeNode(13);
        TreeNode t6 = new TreeNode(4);
        TreeNode t7 = new TreeNode(7);
        TreeNode t8 = new TreeNode(2);
        TreeNode t9 = new TreeNode(5);
        TreeNode t10 = new TreeNode(1);
        t1.left = t2;
        t1.right = t3;
        t2.left = t4;
        t3.left = t5;
        t3.right = t6;
        t4.left = t7;
        t4.right = t8;
        t6.left = t9;
        t6.right = t10;
        int sum = 22;
        List<List<Integer>> listList = pathSum(t1, sum);
        System.out.println("listList = " + listList);


    }

    public static List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> listList = new ArrayList<>();
        if (root == null) {
            return listList;
        }
        List<String> paths = new ArrayList<>();

        LinkedList<TreeNode> deque = new LinkedList<>();
        LinkedList<String> path_back = new LinkedList<>();
        deque.add(root);
        path_back.add(Integer.toString(root.val));
        TreeNode treeNode;
        String path;
        while (!deque.isEmpty()) {
            treeNode = deque.pollLast();
            path = path_back.pollLast();
            if (treeNode.left == null && treeNode.right == null) {
                paths.add(path);
            }
            if (treeNode.left != null) {
                deque.add(treeNode.left);
                path_back.add(path + "," + treeNode.left.val);
            }
            if (treeNode.right != null) {
                deque.add(treeNode.right);
                path_back.add(path + "," + treeNode.right.val);
            }
        }
        paths.stream().map(str -> str.split(",")).forEachOrdered(split -> {
            if (Stream.of(split).filter(Objects::nonNull).
                    filter(x -> !"".equals(x)).mapToInt(Integer::parseInt).sum() == sum) {
                List<Integer> list = new ArrayList<>();
                for (String s : split) {
                    list.add(Integer.parseInt(s));
                }
                listList.addAll(Collections.singleton(list));
            }
        });
        return listList;
    }
}