题目:
我的解法:
从根节点开始,向下迭代寻找到叶子结点的路径,每个路径存为一个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));
}
}