[LeetCode] 863. All Nodes Distance K in Binary Tree

We are given a binary tree (with root node root), a target node, and an integer value k.

Return a list of the values of all nodes that have a distance k from the target node.  The answer can be returned in any order.

Example 1:

Input: root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, k = 2

Output: [7,4,1]

Explanation: 
The nodes that are a distance 2 from the target node (with value 5)
have values 7, 4, and 1.



Note that the inputs "root" and "target" are actually TreeNodes.
The descriptions of the inputs above are just serializations of these objects.

Note:

1. The given tree is non-empty.
2. Each node in the tree has unique values 0 <= node.val <= 500.
3. The target node is a node in the tree.
4. 0 <= k <= 1000.

二叉树中所有距离为 K 的结点。

给定一个二叉树（具有根结点 root）， 一个目标结点 target ，和一个整数值 K 。

返回到目标结点 target 距离为 K 的所有结点的值的列表。 答案可以以任何顺序返回。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/all-nodes-distance-k-in-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这道题非常好，是一道树 tree 和图论 graph 的结合题。这里我提供一个 BFS 的做法。

题目给的 input 是树，但是我们是需要把他转译成图才能做的，这样我们才能既可以知道父节点的邻居有子节点，也可以知道子节点的邻居有父节点。知道这些信息之后，我们从 target 节点开始做 BFS 遍历。因为题目找的是距离 target 节点长度为 K 的节点，所以我们在开始 BFS 遍历的同时，要记得 K--。这样当 K = 0 的时候，如果此时 queue 中有元素，这些元素就都是相距 target 节点，距离为 K 的节点。

时间O(n)

空间O(n)

Java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    HashMap<TreeNode, List<TreeNode>> map = new HashMap<>();
    
    public List<Integer> distanceK(TreeNode root, TreeNode target, int K) {
        List<Integer> res = new ArrayList<>();
        
        // build the graph
        buildGraph(root, null);
        
        // corner case
        if (!map.containsKey(target)) {
            return res;
        }
        
        HashSet<TreeNode> visited = new HashSet<>();
        Queue<TreeNode> queue = new LinkedList<>();
        visited.add(target);
        queue.offer(target);
        while (!queue.isEmpty()) {
            int size = queue.size();
            // 抵达终点
            if (K == 0) {
                for (int i = 0; i < size; i++) {
                    TreeNode cur = queue.poll();
                    res.add(cur.val);
                }
                return res;
            }
            
            // 在路上
            for (int i = 0; i < size; i++) {
                TreeNode cur = queue.poll();
                for (TreeNode next : map.get(cur)) {
                    if (visited.contains(next)) {
                        continue;
                    }
                    visited.add(next);
                    queue.offer(next);
                }
            }
            K--;
        }
        return res;
    }
    
    // 类似前序遍历的方式创建图
    private void buildGraph(TreeNode node, TreeNode parent) {
        // base case
        if (node == null) {
            return;
        }
        if (!map.containsKey(node)) {
            map.put(node, new ArrayList<>());
            if (parent != null) {
                map.get(node).add(parent);
                map.get(parent).add(node);
            }
            buildGraph(node.left, node);
            buildGraph(node.right, node);
        }
    }
}

LeetCode 题目总结