二叉树--路径问题

leetcode 112

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

解法1：递归

public boolean hasPathSum(TreeNode root, int sum) {
    if (root == null){
        return false;
    }
    if (root.left == null && root.right == null){
        return root.val == sum;
    }

    return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
}

解法2：BFS

首先我们可以想到使用广度优先搜索的方式，记录从根节点到当前节点的路径和，以防止重复计算。

这样我们使用两个队列，分别存储将要遍历的节点，以及根节点到这些节点的路径和即可。

public boolean hasPathSum(TreeNode root, int sum) {
    if (root == null){
        return false;
    }

    Queue<TreeNode> queNode = new LinkedList<TreeNode> ();
    Queue<Integer> queVal = new LinkedList<Integer> ();

    queNode.offer(root);
    queVal.offer(root.val);

    while (!queNode.isEmpty()) {

        TreeNode temp = queNode.poll();
        int valTemp = queVal.poll();

        if (temp.left == null && temp.right == null){
            if (valTemp == sum){
                return true;
            }
            continue;//这个continue表示如果遍历到了叶子节点，但是和不等于sum，跳过当前循环，执行下一次循环
        }


        if (temp.left != null){
            queNode.offer(temp.left);
            queVal.offer(valTemp + temp.left.val);
        }

        if (temp.right != null){
            queNode.offer(temp.right);
            queVal.offer(valTemp + temp.right.val);
        }

    }
    return false;
}

---

leetcode 113

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

本解法来源于liweiwei1419

public List<List<Integer>> pathSum(TreeNode root, int sum) {

    List<List<Integer>> res = new LinkedList<>();
    if (root == null){
        return res;
    }

    Deque<Integer> path = new ArrayDeque<>();
    pathSum(root, sum, path, res);
    return res;
}


public void pathSum(TreeNode node, int sum, Deque<Integer> path, List<List<Integer>> res){
    // 递归终止条件
    if (node == null){
        return;
    }
    //沿途节点必须选择，这个时候要做两个事情：
    //1.sum减去这个节点的值
    //2.将这个节点加到path
    sum -= node.val;
    path.addLast(node.val);

    if (sum == 0 && node.left == null && node.right == null){
        res.add(new LinkedList<>(path));
        //必须要清空到最后一个节点，这样才能回溯
        path.removeLast();
        return;//这句话很关键
    }

    pathSum(node.left, sum, path, res);
    pathSum(node.right, sum, path, res);
    //每次递归结束也都必须要清空最后一个节点，这样才能回溯
    path.removeLast();
}