打印与叶节点距离为 k 的所有节点

在二叉树中，如果要打印距离一个叶节点距离为 k 的所有节点，我们可以使用 DFS（深度优先搜索）进行遍历。具体实现步骤如下：

1. 定义一个空列表用于存储结果节点；
2. 从根节点开始遍历整个二叉树，并记录遍历到的节点；
3. 当遍历到一个叶子节点时，我们计算从该叶子节点到跟节点的距离；
4. 如果此距离等于 k，则将该叶子节点添加到结果列表中；
5. 遍历完整棵树后，返回结果列表。

以下是 Python 代码的实现：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def distance_k(root: TreeNode, target: TreeNode, K: int) -> List[int]:
    # 存储从目标节点到每个节点的距离
    parent = {}

    def dfs(node, par=None):
        # 记录每个节点的父节点
        if node:
            parent[node.val] = par
            dfs(node.left, node)
            dfs(node.right, node)

    dfs(root)

    # 存储目标节点->所有节点的距离
    d = {}
    def find(node, pre, distance):
        """
        DFS查找每个节点到目标节点的距离
        """
        if not node:
            return
        d[node.val] = distance
        if node.left != pre:
            find(node.left, node, distance+1)
        if node.right != pre:
            find(node.right, node, distance+1)

    find(target, None, 0)

    # 存储距离目标节点 K 距离的节点
    ans = []
    for n in d:
        if n in parent:
            if d[n] == K:
                ans.append(n)
        if parent[n] and parent[n].val not in d:
            if d[parent[n].val] == K - d[n]:
                ans.append(n)

    return ans

在上面的解决方案中, 我们首先先找到目标节点到每个节点的距离，然后我们查找到距目标节点 K 距离的每个节点。最后，将我们搜索的所有节点添加到结果列表中。

下面是算法的复杂度分析：

时间复杂度： 我们需要遍历整棵树并存储叶子节点到根节点的距离，因此时间复杂度为 O(N)，其中 N 为树中的节点数。

空间复杂度： 我们需要一个哈希表来存储每个节点到目标节点的距离，因此空间复杂度为 O(N)。同时，在 DFS 中，我们使用一个哈希表存储每个节点的父节点，因此总空间复杂度为 O(N)。

总之，我们使用深度优先搜索算法可以轻松打印与叶节点距离为k的所有节点，并且算法的时间和空间复杂度都是 O(N)。