算法---LeetCode 113. 路径总和 II

1. 题目

原题链接

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：[]

示例 3：

输入：root = [1,2], targetSum = 0
输出：[]

提示：

树中节点总数在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

Related Topics 树 深度优先搜索
👍 507 👎 0

2. 题解

2.1 解法1: DFS

利用先序遍历递归查找合适路径, 自根节点开始做减法, 直到为0

1. 终止条件
   a.root==null
   b. sum==0&&root.left==null && root.right==null

    class Solution {
        public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
            List<List<Integer>> ans = new ArrayList<>();
            dfs(root, targetSum, new ArrayList<>(), ans);
            return ans;
        }

        public void dfs(TreeNode root, int sum, List<Integer> pathList, List<List<Integer>> ans) {
            // 递归终止条件 1：遇到空结点不再递归调用
            if (root == null) return;
            // 沿途结点必须选择，这个时候要做两件事：1、sum 减去这个结点的值；2、添加到 path 里
            sum -= root.val;
            pathList.add(root.val);
            // 递归终止条件 2：遇到叶子结点，sum 恰好为 0，说明从根结点到叶子结点的路径是一个符合要求的解
            if (sum == 0 && root.left == null && root.right == null) {
                ans.add(new ArrayList<>(pathList));
            }
            dfs(root.left, sum, pathList, ans);
            dfs(root.right, sum, pathList, ans);
            // 递归完成以后，必须重置变量
            pathList.remove(pathList.size() - 1);
        }

    }

参考:
回溯算法（Java）

2.2 解法2: BFS

参考: DFS，BFS共5种方式解决，2种击败了100%的用户

    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> res = new ArrayList<>();
        //如果节点为空直接返回
        if (root == null)
            return res;
        //使用两个队列，一个存储结点，一个存储从更结点到当前节点的路径
        Queue<TreeNode> queueNode = new LinkedList<>();
        Queue<List<Integer>> queueList = new LinkedList<>();
        //根节点入队
        queueNode.add(root);
        //根节点的路径入队
        List<Integer> list = new ArrayList<>();
        list.add(root.val);
        queueList.add(list);

        while (!queueNode.isEmpty()) {
            //当前节点出队
            TreeNode node = queueNode.poll();
            //当前节点的路径出队
            List<Integer> tempList = queueList.poll();
            if (node.left == null && node.right == null && node.val == sum) {
                //如果满足条件，就把路径存储到res中
                res.add(tempList);
            }
            //左子节点不为空，左子节点和路径入队
            if (node.left != null) {
                tempList.add(node.left.val);
                queueList.add(new ArrayList<>(tempList));
                node.left.val += node.val;
                queueNode.add(node.left);
                tempList.remove(tempList.size() - 1);
            }
            //右子节点不为空，右子节点和路径入队
            if (node.right != null) {
                tempList.add(node.right.val);
                queueList.add(new ArrayList<>(tempList));
                node.right.val += node.val;
                queueNode.add(node.right);
            }
        }
        return res;
    }

---

题外话

关于ArrayDeque与LinkedList实现的栈方法

push() 相当于 addFirst(), 在头部添加元素
pop() 相当于 removeFirst(), 在头部删除

注意不是在尾部添加, 在某些初始化时候可能顺序会出错, 如 113. 路径总和 II 题解

所以在回溯算法中, 建议使用 ArrayList 来进行尾部元素的添加删除操作, 这样熟悉且不容易出错