剑指offer编程题解法汇总24-二叉树中和为某一值的路径

二叉树中和为某一值的路径

题目描述

输入一颗二叉树的根节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

 

解题思路：

第一种思路，肯定是顺序遍历，找出所有的等于N的数值的叶子节点的数组，加到总的集合里面。最后进行一个排序就好了。

这种思路可以解题，但是肯定是最low的方式，我先把这种方式的解题代码列一下：

public class Solution {


    ArrayList<ArrayList<Integer>> allResultList = new ArrayList<>();

    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
        if (root == null) {
            return new ArrayList<>();
        }
        ArrayList<Integer> list = new ArrayList<>();
        test(list, root, 0, target);

        allResultList.sort(new Comparator<ArrayList<Integer>>() {
            @Override
            public int compare(ArrayList<Integer> o1, ArrayList<Integer> o2) {
                return o1.size() > o2.size() ? 0 : 1;
            }
        });
        return allResultList;
    }

    /**
     * 第一种方式，计算出所有合适的节点之后，加入到了List里面之后进行排序
     */
    public void test(ArrayList<Integer> list, TreeNode node, int currentValue, int target) {
        if (node.left != null) {
            ArrayList<Integer> newlist = new ArrayList<>();
            newlist.addAll(list);
            newlist.add(node.val);
            test(newlist, node.left, currentValue + (node.val), target);
        }
        if (node.right != null) {
            ArrayList<Integer> newlist = new ArrayList<>();
            newlist.addAll(list);
            newlist.add(node.val);
            test(newlist, node.right, currentValue + (node.val), target);
        }
        if (node.left == null && node.right == null) {
            if ((node.val + currentValue) == target) {
                list.add(node.val);
                allResultList.add(list);
            }
        }

    }
}

 

 

 

第二种思路，缓存所有的能够遍历到叶子节点的排列的数组，以及对应值。节点的话一层一层的遍历，当遍历到某一层不存在节点时，回头去检查一下之前缓存的数组的集合中是否有满足条件的，如果有，则添加到集合中返回。

public class Solution {
    
    ArrayList<ArrayList<Integer>> allResultList = new ArrayList<>();
    ArrayList<ArrayList<Integer>> leafList = new ArrayList<>();
    ArrayList<Integer> leafValueList = new ArrayList<>();
    
   public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
        if (root == null) {
            return new ArrayList<>();
        }
        ArrayList<TreeNode> nodeList = new ArrayList<>();
        ArrayList<Integer> currentValueList = new ArrayList<>();
        ArrayList<ArrayList<Integer>> historyList = new ArrayList<>();

        nodeList.add(root);
        currentValueList.add(root.val);
        ArrayList<Integer> nextlist = new ArrayList<>();
        nextlist.add(root.val);
        historyList.add(nextlist);
        test2(nodeList, currentValueList, historyList, target);

        return allResultList;
    }

    /**
     * 第二种方式
     * 按照层级去遍历所有节点，而不是递归
     * list代表
     */
    public void test2(ArrayList<TreeNode> nodeList, ArrayList<Integer> currentValueList, ArrayList<ArrayList<Integer>> historyList, int target) {
        if (nodeList.size() == 0) {
            //遍历输出
            for (int i = leafValueList.size() - 1; i >= 0; i--) {
                Integer integer = leafValueList.get(i);
                ArrayList<Integer> arrayList = leafList.get(i);
                if (integer == target) {
                    allResultList.add(arrayList);
                }
            }
            return;
        }
        ArrayList<TreeNode> nextNodeList = new ArrayList<>();
        ArrayList<Integer> nextCurrentValueList = new ArrayList<>();
        ArrayList<ArrayList<Integer>> nextHistoryList = new ArrayList<>();

        for (int i = 0; i < nodeList.size(); i++) {
            TreeNode treeNode = nodeList.get(i);
            Integer value = currentValueList.get(i);
            ArrayList<Integer> arrayList = historyList.get(i);

            if (treeNode.left == null && treeNode.right == null) {
                leafList.add(arrayList);
                leafValueList.add(value);
                continue;
            }

             if (treeNode.left != null) {
                nextNodeList.add(treeNode.left);
                nextCurrentValueList.add(value + treeNode.left.val);
                ArrayList<Integer> nextList = new ArrayList<>();
                nextList.addAll(arrayList);
                nextList.add(treeNode.left.val);
                nextHistoryList.add(nextList);
            }
            if (treeNode.right != null) {
                nextNodeList.add(treeNode.right);
                nextCurrentValueList.add(value + treeNode.right.val);
                ArrayList<Integer> nextList = new ArrayList<>();
                nextList.addAll(arrayList);
                nextList.add(treeNode.right.val);
                nextHistoryList.add(nextList);
            }
        }
        test2(nextNodeList, nextCurrentValueList, nextHistoryList, target);
    }
}