# Print all nodes at distance k from a given node

Given a binary tree, a target node in the binary tree, and an integer value k, print all the nodes that are at distance k from the given target node. No parent pointers are available.

Consider the tree shown in diagram
Input: target = pointer to node with data 8.
root = pointer to node with data 20.
k = 2.
Output : 10 14 22
If target is 14 and k is 3, then output
should be “4 20”

There are two types of nodes to be considered.
1) Nodes in the subtree rooted with target node. For example, if the target node is 8 and k is 2, then such nodes are 10 and 14.
2) Other nodes, may be an ancestor of target, or a node in some other subtree. For target node 8 and k is 2, the node 22 comes in this category.
Finding the first type of nodes is easy to implement. Just traverse subtrees rooted with the target node and decrement k in recursive call. When the k becomes 0, print the node currently being traversed (See this for more details). Here we call the function as printkdistanceNodeDown().
How to find nodes of second type? For the output nodes not lying in the subtree with the target node as the root, we must go through all ancestors. For every ancestor, we find its distance from target node, let the distance be d, now we go to other subtree (if target was found in left subtree, then we go to right subtree and vice versa) of the ancestor and find all nodes at k-d distance from the ancestor.

Following is the implementation of the above approach.

## C++

 `#include``using` `namespace` `std;` `// A binary Tree node``struct` `Node{``    ``int` `data;``    ``Node* left;``    ``Node* right;``};` `// Recursive function to print all the nodes at distance k in the``// tree (or subtree) rooted with given root. See */``void` `printkdistanceNodeDown(Node* root, ``int` `k){``    ``// Base Case``    ``if` `(root == NULL || k < 0) ``return``;` `    ``// If we reach a k distant node, print it``    ``if` `(k==0){``        ``cout<< root->data<left, k-1);``    ``printkdistanceNodeDown(root->right, k-1);``}` `// Prints all nodes at distance k from a given target node.``// The k distant nodes may be upward or downward. This function``// Returns distance of root from target node, it returns ``// -1 if target node is not present in tree rooted with root.``int` `printkdistanceNode(Node* root, Node* target , ``int` `k){``    ``// Base Case 1: If tree is empty, return -1``    ``if` `(root == NULL) ``return` `-1;` `    ``// If target is same as root. Use the downward function``    ``// to print all nodes at distance k in subtree rooted with``    ``// target or root``    ``if` `(root == target){``        ``printkdistanceNodeDown(root, k);``        ``return` `0;``    ``}` `    ``// Recur for left subtree``    ``int` `dl = printkdistanceNode(root->left, target, k);` `    ``// Check if target node was found in left subtree``    ``if` `(dl != -1){``        ``// If root is at distance k from target, print root``        ``// Note that dl is Distance of root's ``        ``// left child from target``        ``if` `(dl + 1 == k)``            ``cout<data<right, k-dl-2);` `        ``// Add 1 to the distance and return value for parent calls``        ``return` `1 + dl;``    ``}` `    ``// MIRROR OF ABOVE CODE FOR RIGHT SUBTREE``    ``// Note that we reach here only when node was ``    ``// not found in left subtree``    ``int` `dr = printkdistanceNode(root->right, target, k);``    ``if` `(dr != -1){``        ``if` `(dr + 1 == k)``            ``cout<data<left, k-dr-2);``        ``return` `1 + dr;``    ``}` `    ``// If target was neither present in left``    ``// nor in right subtree``    ``return` `-1;``}` `// A utility function to create a new binary tree node``Node* newNode(``int` `data){``    ``Node* temp = ``new` `Node();``    ``temp->data = data;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// Driver program to test above functions``int` `main(){``    ``// Let us construct the tree shown in above diagram``    ``Node* root = newNode(20);``    ``root->left = newNode(8);``    ``root->right = newNode(22);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(12);``    ``root->left->right->left = newNode(10);``    ``root->left->right->right = newNode(14);``    ``Node* target = root->left->right;``    ``printkdistanceNode(root, target, 2);``    ``return` `0;``}`

## Java

 `// Java program to print all nodes at a distance k from given node` `// A binary tree node``class` `Node ``{``    ``int` `data;``    ``Node left, right;`` ` `    ``Node(``int` `item) ``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}`` ` `class` `BinaryTree ``{``    ``Node root;``    ``/* Recursive function to print all the nodes at distance k in``       ``tree (or subtree) rooted with given root. */`` ` `    ``void` `printkdistanceNodeDown(Node node, ``int` `k) ``    ``{``        ``// Base Case``        ``if` `(node == ``null` `|| k < ``0``)``            ``return``;`` ` `        ``// If we reach a k distant node, print it``        ``if` `(k == ``0``) ``        ``{``            ``System.out.print(node.data);``            ``System.out.println(``""``);``            ``return``;``        ``}`` ` `        ``// Recur for left and right subtrees``        ``printkdistanceNodeDown(node.left, k - ``1``);``        ``printkdistanceNodeDown(node.right, k - ``1``);``    ``}`` ` `    ``// Prints all nodes at distance k from a given target node.``    ``// The k distant nodes may be upward or downward.This function``    ``// Returns distance of root from target node, it returns -1``    ``// if target node is not present in tree rooted with root.``    ``int` `printkdistanceNode(Node node, Node target, ``int` `k) ``    ``{``        ``// Base Case 1: If tree is empty, return -1``        ``if` `(node == ``null``)``            ``return` `-``1``;`` ` `        ``// If target is same as root.  Use the downward function``        ``// to print all nodes at distance k in subtree rooted with``        ``// target or root``        ``if` `(node == target) ``        ``{``            ``printkdistanceNodeDown(node, k);``            ``return` `0``;``        ``}`` ` `        ``// Recur for left subtree``        ``int` `dl = printkdistanceNode(node.left, target, k);`` ` `        ``// Check if target node was found in left subtree``        ``if` `(dl != -``1``) ``        ``{``             ` `            ``// If root is at distance k from target, print root``            ``// Note that dl is Distance of root's left child from ``            ``// target``            ``if` `(dl + ``1` `== k) ``            ``{``                ``System.out.print(node.data);``                ``System.out.println(``""``);``            ``}``             ` `            ``// Else go to right subtree and print all k-dl-2 distant nodes``            ``// Note that the right child is 2 edges away from left child``            ``else``                ``printkdistanceNodeDown(node.right, k - dl - ``2``);`` ` `            ``// Add 1 to the distance and return value for parent calls``            ``return` `1` `+ dl;``        ``}`` ` `        ``// MIRROR OF ABOVE CODE FOR RIGHT SUBTREE``        ``// Note that we reach here only when node was not found in left ``        ``// subtree``        ``int` `dr = printkdistanceNode(node.right, target, k);``        ``if` `(dr != -``1``) ``        ``{``            ``if` `(dr + ``1` `== k) ``            ``{``                ``System.out.print(node.data);``                ``System.out.println(``""``);``            ``} ``            ``else``                ``printkdistanceNodeDown(node.left, k - dr - ``2``);``            ``return` `1` `+ dr;``        ``}`` ` `        ``// If target was neither present in left nor in right subtree``        ``return` `-``1``;``    ``}`` ` `    ``// Driver program to test the above functions``    ``public` `static` `void` `main(String args[]) ``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();`` ` `        ``/* Let us construct the tree shown in above diagram */``        ``tree.root = ``new` `Node(``20``);``        ``tree.root.left = ``new` `Node(``8``);``        ``tree.root.right = ``new` `Node(``22``);``        ``tree.root.left.left = ``new` `Node(``4``);``        ``tree.root.left.right = ``new` `Node(``12``);``        ``tree.root.left.right.left = ``new` `Node(``10``);``        ``tree.root.left.right.right = ``new` `Node(``14``);``        ``Node target = tree.root.left.right;``        ``tree.printkdistanceNode(tree.root, target, ``2``);``    ``}``}`` ` `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# Python program to print nodes at distance k from a given node` `# A binary tree node ``class` `Node:``    ``# A constructor to create a new node``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None``    ` `# Recursive function to print all the nodes at distance k``# int the tree(or subtree) rooted with given root. See ``def` `printkDistanceNodeDown(root, k):``    ` `    ``# Base Case``    ``if` `root ``is` `None` `or` `k< ``0` `:``        ``return``    ` `    ``# If we reach a k distant node, print it``    ``if` `k ``=``=` `0` `:``        ``print` `(root.data)``        ``return``    ` `    ``# Recur for left and right subtree``    ``printkDistanceNodeDown(root.left, k``-``1``)``    ``printkDistanceNodeDown(root.right, k``-``1``)`  `# Prints all nodes at distance k from a given target node``# The k distant nodes may be upward or downward. This function``# returns distance of root from target node, it returns -1 ``# if target node is not present in tree rooted with root``def` `printkDistanceNode(root, target, k):``    ` `    ``# Base Case 1 : IF tree is empty return -1``    ``if` `root ``is` `None``:``        ``return` `-``1` `    ``# If target is same as root. Use the downward function``    ``# to print all nodes at distance k in subtree rooted with``    ``# target or root``    ``if` `root ``=``=` `target:``        ``printkDistanceNodeDown(root, k)``        ``return` `0``    ` `    ``# Recur for left subtree``    ``dl ``=` `printkDistanceNode(root.left, target, k)``    ` `    ``# Check if target node was found in left subtree``    ``if` `dl !``=` `-``1``:``        ` `        ``# If root is at distance k from target, print root``        ``# Note: dl is distance of root's left child ``        ``# from target``        ``if` `dl ``+``1` `=``=` `k :``            ``print` `(root.data)``    ` `        ``# Else go to right subtree and print all k-dl-2``        ``# distant nodes ``        ``# Note: that the right child is 2 edges away from``        ``# left child``        ``else``:``            ``printkDistanceNodeDown(root.right, k``-``dl``-``2``)` `        ``# Add 1 to the distance and return value for``        ``# for parent calls ``        ``return` `1` `+` `dl` `    ``# MIRROR OF ABOVE CODE FOR RIGHT SUBTREE``    ``# Note that we reach here only when node was not found``    ``# in left subtree``    ``dr ``=` `printkDistanceNode(root.right, target, k)``    ``if` `dr !``=` `-``1``:``        ``if` `(dr``+``1` `=``=` `k):``            ``print` `(root.data)``        ``else``:``            ``printkDistanceNodeDown(root.left, k``-``dr``-``2``)``        ``return` `1` `+` `dr` `    ``# If target was neither present in left nor in right subtree``    ``return` `-``1` `# Driver program to test above function``root ``=` `Node(``20``)``root.left ``=` `Node(``8``)``root.right ``=` `Node(``22``)``root.left.left ``=` `Node(``4``)``root.left.right ``=` `Node(``12``)``root.left.right.left ``=` `Node(``10``)``root.left.right.right ``=` `Node(``14``)``target ``=` `root.left.right``printkDistanceNode(root, target, ``2``)` `# This code is contributed by Nikhil Kumar Singh(nickzuck_007)`

## C#

 `using` `System;` `// C# program to print all nodes at a distance k from given node ` `// A binary tree node ``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `public` `class` `BinaryTree``{``    ``public` `Node root;``    ``/* Recursive function to print all the nodes at distance k in ``       ``tree (or subtree) rooted with given root. */` `    ``public` `virtual` `void` `printkdistanceNodeDown(Node node, ``int` `k)``    ``{``        ``// Base Case ``        ``if` `(node == ``null` `|| k < 0)``        ``{``            ``return``;``        ``}` `        ``// If we reach a k distant node, print it ``        ``if` `(k == 0)``        ``{``            ``Console.Write(node.data);``            ``Console.WriteLine(``""``);``            ``return``;``        ``}` `        ``// Recur for left and right subtrees ``        ``printkdistanceNodeDown(node.left, k - 1);``        ``printkdistanceNodeDown(node.right, k - 1);``    ``}` `    ``// Prints all nodes at distance k from a given target node. ``    ``// The k distant nodes may be upward or downward.This function ``    ``// Returns distance of root from target node, it returns -1 ``    ``// if target node is not present in tree rooted with root. ``    ``public` `virtual` `int` `printkdistanceNode(Node node, Node target, ``int` `k)``    ``{``        ``// Base Case 1: If tree is empty, return -1 ``        ``if` `(node == ``null``)``        ``{``            ``return` `-1;``        ``}` `        ``// If target is same as root.  Use the downward function ``        ``// to print all nodes at distance k in subtree rooted with ``        ``// target or root ``        ``if` `(node == target)``        ``{``            ``printkdistanceNodeDown(node, k);``            ``return` `0;``        ``}` `        ``// Recur for left subtree ``        ``int` `dl = printkdistanceNode(node.left, target, k);` `        ``// Check if target node was found in left subtree ``        ``if` `(dl != -1)``        ``{` `            ``// If root is at distance k from target, print root ``            ``// Note that dl is Distance of root's left child from  ``            ``// target ``            ``if` `(dl + 1 == k)``            ``{``                ``Console.Write(node.data);``                ``Console.WriteLine(``""``);``            ``}` `            ``// Else go to right subtree and print all k-dl-2 distant nodes ``            ``// Note that the right child is 2 edges away from left child ``            ``else``            ``{``                ``printkdistanceNodeDown(node.right, k - dl - 2);``            ``}` `            ``// Add 1 to the distance and return value for parent calls ``            ``return` `1 + dl;``        ``}` `        ``// MIRROR OF ABOVE CODE FOR RIGHT SUBTREE ``        ``// Note that we reach here only when node was not found in left  ``        ``// subtree ``        ``int` `dr = printkdistanceNode(node.right, target, k);``        ``if` `(dr != -1)``        ``{``            ``if` `(dr + 1 == k)``            ``{``                ``Console.Write(node.data);``                ``Console.WriteLine(``""``);``            ``}``            ``else``            ``{``                ``printkdistanceNodeDown(node.left, k - dr - 2);``            ``}``            ``return` `1 + dr;``        ``}` `        ``// If target was neither present in left nor in right subtree ``        ``return` `-1;``    ``}` `    ``// Driver program to test the above functions ``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();` `        ``/* Let us construct the tree shown in above diagram */``        ``tree.root = ``new` `Node(20);``        ``tree.root.left = ``new` `Node(8);``        ``tree.root.right = ``new` `Node(22);``        ``tree.root.left.left = ``new` `Node(4);``        ``tree.root.left.right = ``new` `Node(12);``        ``tree.root.left.right.left = ``new` `Node(10);``        ``tree.root.left.right.right = ``new` `Node(14);``        ``Node target = tree.root.left.right;``        ``tree.printkdistanceNode(tree.root, target, 2);``    ``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output
```4
20

```

Time Complexity: At first look the time complexity looks more than O(n), but if we take a closer look, we can observe that no node is traversed more than twice. Therefore the time complexity is O(n).

The space complexity of this program is O(h),

Alternate Solution :

1. Get Path from the Root node and add into a list
2. For each ith element from Path just iterate and print (K-i)th distance nodes.

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `struct` `TreeNode {``    ``int` `val;``    ``TreeNode* left;``    ``TreeNode* right;``    ``TreeNode(``int` `val)``    ``{``        ``this``->val = val;``        ``this``->left = NULL;``        ``this``->right = NULL;``    ``}``};` `// global variable``vector path;` `// finding the path of target node from root node``bool` `findPath(TreeNode* node, TreeNode* target)``{``    ``if` `(node == NULL) {``        ``return` `false``;``    ``}``    ``if` `(node == target || findPath(node->left, target)``        ``|| findPath(node->right, target)) {``        ``path.push_back(node);``        ``return` `true``;``    ``}``    ``return` `false``;``}` `// blocker is used for ancestors node if target at``// left than we have to go in right or if target at right``// then we have to go in left.``void` `findKDistanceFromNode(TreeNode* node, ``int` `dist,``                           ``vector<``int``>& result,``                           ``TreeNode* blocker)``{``    ``if` `(dist < 0 || node == NULL``        ``|| (blocker != NULL && node == blocker)) {``        ``return``;``    ``}``    ``if` `(dist == 0) {``        ``result.push_back(node->val);``    ``}` `    ``findKDistanceFromNode(node->left, dist - 1, result,``                          ``blocker);``    ``findKDistanceFromNode(node->right, dist - 1, result,``                          ``blocker);``}` `// finding all the nodes at a distance k from target``vector<``int``> distanceK(TreeNode* root, TreeNode* target,``                      ``int` `K)``{``    ``findPath(root, target);``    ``vector<``int``> result;``    ``for` `(``int` `i = 0; i < path.size(); i++) {``        ``findKDistanceFromNode(path[i], K - i, result,``                              ``i == 0 ? NULL : path[i - 1]);``    ``}``    ``// returning list of all nodes at a distance K``    ``return` `result;``}` `// driver program to test the above functions``int` `main()``{``    ``TreeNode* root = ``new` `TreeNode(20);``    ``root->left = ``new` `TreeNode(8);``    ``root->right = ``new` `TreeNode(22);``    ``root->left->left = ``new` `TreeNode(4);``    ``root->left->right = ``new` `TreeNode(12);``    ``root->left->right->left = ``new` `TreeNode(10);``    ``root->left->right->right = ``new` `TreeNode(4);``    ``TreeNode* target = root->left->right;``    ``vector<``int``> result = distanceK(root, target, 2);``    ``cout << ``"["``;``    ``for` `(``int` `i = 0; i < result.size() - 1; i++) {``        ``cout << result[i] << ``", "``;``    ``}``    ``cout << result[result.size() - 1] << ``"]"` `<< endl;``    ``return` `0;``}` `// this code is contributed by Yash``// Agarwal(yashagarwal2852002)`

## Java

 `import` `java.io.*;``import` `java.util.*;` `class` `TreeNode {``    ``public` `int` `val;``    ``public` `TreeNode left;``    ``public` `TreeNode right;``    ``public` `TreeNode() {}` `    ``public` `TreeNode(``int` `val) { ``this``.val = val; }``}` `class` `GFG {``    ``List path = ``null``;``      ``//Finding all the nodes at a distance K from target``      ``//node.``    ``public` `List distanceK(TreeNode root,``                                   ``TreeNode target, ``int` `K)``    ``{``        ``path = ``new` `ArrayList<>();``        ``findPath(root, target);``        ``List result = ``new` `ArrayList<>();``        ``for` `(``int` `i = ``0``; i < path.size(); i++) {``            ``findKDistanceFromNode(``                ``path.get(i), K - i, result,``                ``i == ``0` `? ``null` `: path.get(i - ``1``));``        ``}``          ``//Returning list of all nodes at a distance K``        ``return` `result;``    ``}` `    ``// Blocker is used for ancestors node if target at ``      ``//left then we have to go in right or if target at ``      ``// right then we have to go in left.``    ``public` `void` `findKDistanceFromNode(TreeNode node,``                                      ``int` `dist,``                                      ``List result,``                                      ``TreeNode blocker)``    ``{``        ``if` `(dist < ``0` `|| node == ``null``            ``|| (blocker != ``null` `&& node == blocker)) {``            ``return``;``        ``}` `        ``if` `(dist == ``0``) {``            ``result.add(node.val);``        ``}` `        ``findKDistanceFromNode(node.left, dist - ``1``, result,``                              ``blocker);``        ``findKDistanceFromNode(node.right, dist - ``1``, result,``                              ``blocker);``    ``}``    ``//Finding the path of target node from root node``    ``public` `boolean` `findPath(TreeNode node, TreeNode target)``    ``{``        ``if` `(node == ``null``)``            ``return` `false``;` `        ``if` `(node == target || findPath(node.left, target)``            ``|| findPath(node.right, target)) {``            ``path.add(node);``            ``return` `true``;``        ``}` `        ``return` `false``;``    ``}``     ``// Driver program to test the above functions``    ``public` `static` `void` `main(String[] args)``    ``{``        ``GFG gfg = ``new` `GFG();``        ``/* Let us construct the tree shown in above diagram */``        ``TreeNode root = ``new` `TreeNode(``20``);``        ``root.left = ``new` `TreeNode(``8``);``        ``root.right = ``new` `TreeNode(``22``);``        ``root.left.left = ``new` `TreeNode(``4``);``        ``root.left.right = ``new` `TreeNode(``12``);``        ``root.left.right.left = ``new` `TreeNode(``10``);``        ``root.left.right.right = ``new` `TreeNode(``14``);``        ``TreeNode target = root.left.right;``        ``System.out.println(gfg.distanceK(root, target, ``2``));``    ``}``}`

## Python3

 `class` `TreeNode:``    ``def` `__init__(``self``, val``=``0``, left``=``None``, right``=``None``):``        ``self``.val ``=` `val``        ``self``.left ``=` `left``        ``self``.right ``=` `right` `class` `GFG:``    ``path ``=` `None` `    ``def` `distanceK(``self``, root: TreeNode, target: TreeNode, K: ``int``):``        ``self``.path ``=` `[]``        ``self``.findPath(root, target)``        ``result ``=` `[]``        ``for` `i ``in` `range``(``len``(``self``.path)):``            ``self``.findKDistanceFromNode(``self``.path[i], K``-``i, result, ``None` `if` `i ``=``=` `0` `else` `self``.path[i``-``1``])``        ``return` `result` `    ``def` `findKDistanceFromNode(``self``, node, dist, result, blocker: TreeNode):``        ``if` `dist < ``0` `or` `node ``is` `None` `or` `(blocker ``is` `not` `None` `and` `node ``=``=` `blocker):``            ``return``        ``if` `dist ``=``=` `0``:``            ``result.append(node.val)``        ``self``.findKDistanceFromNode(node.left, dist``-``1``, result, blocker)``        ``self``.findKDistanceFromNode(node.right, dist``-``1``, result, blocker)` `    ``def` `findPath(``self``, node: TreeNode, target: TreeNode) ``-``> ``bool``:``        ``if` `node ``is` `None``:``            ``return` `False``        ``if` `node ``=``=` `target ``or` `self``.findPath(node.left, target) ``or` `self``.findPath(node.right, target):``            ``self``.path.append(node)``            ``return` `True``        ``return` `False` `if` `__name__ ``=``=` `"__main__"``:``    ``gfg ``=` `GFG()``    ``root ``=` `TreeNode(``20``)``    ``root.left ``=` `TreeNode(``8``)``    ``root.right ``=` `TreeNode(``22``)``    ``root.left.left ``=` `TreeNode(``4``)``    ``root.left.right ``=` `TreeNode(``12``)``    ``root.left.right.left ``=` `TreeNode(``10``)``    ``root.left.right.right ``=` `TreeNode(``14``)``    ``target ``=` `root.left.right``    ``print``(gfg.distanceK(root, target, ``2``))`

## C#

 `using` `System;``using` `System.Collections.Generic;` `// TreeNode class``public` `class` `TreeNode``{``    ``public` `int` `val;``    ``public` `TreeNode left;``    ``public` `TreeNode right;` `    ``public` `TreeNode() {}` `    ``public` `TreeNode(``int` `val)``    ``{``        ``this``.val = val;``    ``}``}` `// GFG class``class` `GFG``{``    ``List path = ``null``;` `    ``// Finding all the nodes at a distance K from target node.``    ``public` `List<``int``> DistanceK(TreeNode root, TreeNode target, ``int` `K)``    ``{``        ``path = ``new` `List();``        ``FindPath(root, target);` `        ``List<``int``> result = ``new` `List<``int``>();``        ``for` `(``int` `i = 0; i < path.Count; i++)``        ``{``            ``FindKDistanceFromNode(``                ``path[i], K - i, result,``                ``i == 0 ? ``null` `: path[i - 1]);``        ``}` `        ``// Returning a list of all nodes at a distance K``        ``return` `result;``    ``}` `    ``// Blocker is used for ancestor nodes. If target is at left then we have to go in right ``    ``// or if target is at right then we have to go in left.``    ``public` `void` `FindKDistanceFromNode(TreeNode node, ``int` `dist, List<``int``> result, TreeNode blocker)``    ``{``        ``if` `(dist < 0 || node == ``null` `|| (blocker != ``null` `&& node == blocker))``        ``{``            ``return``;``        ``}` `        ``if` `(dist == 0)``        ``{``            ``result.Add(node.val);``        ``}` `        ``FindKDistanceFromNode(node.left, dist - 1, result, blocker);``        ``FindKDistanceFromNode(node.right, dist - 1, result, blocker);``    ``}` `    ``// Finding the path of target node from root node.``    ``public` `bool` `FindPath(TreeNode node, TreeNode target)``    ``{``        ``if` `(node == ``null``)``            ``return` `false``;` `        ``if` `(node == target || FindPath(node.left, target) || FindPath(node.right, target))``        ``{``            ``path.Add(node);``            ``return` `true``;``        ``}` `        ``return` `false``;``    ``}` `    ``// Driver program to test the above functions``    ``static` `void` `Main(``string``[] args)``    ``{``        ``GFG gfg = ``new` `GFG();` `        ``/* Let us construct the tree shown in above diagram */``        ``TreeNode root = ``new` `TreeNode(20);``        ``root.left = ``new` `TreeNode(8);``        ``root.right = ``new` `TreeNode(22);``        ``root.left.left = ``new` `TreeNode(4);``        ``root.left.right = ``new` `TreeNode(12);``        ``root.left.right.left = ``new` `TreeNode(10);``        ``root.left.right.right = ``new` `TreeNode(14);` `        ``TreeNode target = root.left.right;``        ``Console.WriteLine(``string``.Join(``", "``, gfg.DistanceK(root, target, 2)));``    ``}``}`

## Javascript

 ``

Output
```[4, 20]

```

Time complexity: O(n)

Approach Using BFS:-

• We will be using level order traversal to print nodes

Implementation:-

• First we will find the target node using level order traversal.
• While finding the target node we will store the parent of each node so that we can move towards the parent of the node as well.
• After this we will traverse from the target node to all the three directions that is toward both child and parent till distance K and print the nodes at distance K.

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `struct` `TreeNode {``    ``int` `val;``    ``TreeNode* left;``    ``TreeNode* right;``    ``TreeNode(``int` `val)``    ``{``        ``this``->val = val;``        ``this``->left = NULL;``        ``this``->right = NULL;``    ``}``};` `// finding all the nodes at a distance k from target``vector<``int``> distanceK(TreeNode* root, TreeNode* target,``                      ``int` `K)``{``  ``//vector to store answer``  ``vector<``int``>ans;``  ` `  ``//queue for bfs``  ``queue q;``  ` `  ``q.push(root);``  ` `  ``//to store target node``  ``TreeNode* need;``  ` `  ``//map to store parent of each node``  ``unordered_map m;``  ` `  ``//bfs``  ``while``(q.size()){``    ` `    ``int` `s = q.size();``    ` `    ``//traversing to current level``    ``for``(``int` `i=0;ileft){``        ``q.push(temp->left);``        ``m[temp->left]=temp;``      ``}``      ` `      ``if``(temp->right){``        ``q.push(temp->right);``        ``m[temp->right]=temp;``      ``}``      ` `    ``}``    ` `  ``}``  ` `  ``//map to store occurrence of a node``  ``//that is the node has taken or not``  ``unordered_map mm;``  ` `  ``q.push(need);``  ` `  ``//to store current distance``  ``int` `c = 0;``  ` `  ``while``(q.size()){``    ` `    ``int` `s = q.size();``    ` `    ``for``(``int` `i=0;ival);``      ` `      ``//moving left``      ``if``(temp->left&&mm[temp->left]==0){``        ``q.push(temp->left);``      ``}``      ` `      ``//moving right``      ``if``(temp->right&&mm[temp->right]==0){``        ``q.push(temp->right);``      ``}``      ` `      ``//moving to parent``      ``if``(m[temp]&&mm[m[temp]]==0){``        ``q.push(m[temp]);``      ``}``      ` `    ``}``    ` `    ``c++;``    ``if``(c>K)``break``;``    ` `  ``}``  ``return` `ans;``}` `// driver program to test the above functions``int` `main()``{``    ``TreeNode* root = ``new` `TreeNode(20);``    ``root->left = ``new` `TreeNode(8);``    ``root->right = ``new` `TreeNode(22);``    ``root->left->left = ``new` `TreeNode(4);``    ``root->left->right = ``new` `TreeNode(12);``    ``root->left->right->left = ``new` `TreeNode(10);``    ``root->left->right->right = ``new` `TreeNode(4);``    ``TreeNode* target = root->left->right;``    ``vector<``int``> result = distanceK(root, target, 2);``    ``cout << ``"["``;``    ``for` `(``int` `i = 0; i < result.size() - 1; i++) {``        ``cout << result[i] << ``", "``;``    ``}``    ``cout << result[result.size() - 1] << ``"]"` `<< endl;``    ``return` `0;``}` `// this code is contributed by shubhamrajput6156`

## Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.util.*;` `// creating tree node``class` `TreeNode {``    ``int` `val;``    ``TreeNode left;``    ``TreeNode right;` `    ``public` `TreeNode(``int` `val) {``        ``this``.val = val;``        ``this``.left = ``null``;``        ``this``.right = ``null``;``    ``}``}` `public` `class` `Main {` `  ``// finding all the nodes at a distance k from target``    ``public` `static` `List distanceK(TreeNode root, TreeNode target, ``int` `K) {``      ` `      ``// list for answer storing``        ``List ans = ``new` `ArrayList<>();``      ` `      ``// Queue for bfs``        ``Queue q = ``new` `LinkedList<>();``        ``q.offer(root);`` ` `        ``TreeNode need = ``null``;``       ` `      ``//map to store parent of each node``        ``Map m = ``new` `HashMap<>();` `        ``while` `(!q.isEmpty()) {``            ``int` `s = q.size();``          ` `          ``// traversing the current level``            ``for` `(``int` `i = ``0``; i < s; i++) {``                ``TreeNode temp = q.poll();``                ` `              ``// if target found then``                ``if` `(temp == target) {``                    ``need = temp;``                ``}``                ` `                ``if` `(temp.left != ``null``) {``                    ``q.offer(temp.left);``                    ``m.put(temp.left, temp);``                ``}``                ` `                ``if` `(temp.right != ``null``) {``                    ``q.offer(temp.right);``                    ``m.put(temp.right, temp);``                ``}``            ``}``        ``}` `   ``//map to store occurrence of a node``  ``//that is the node has taken or not``        ``Map mm = ``new` `HashMap<>();``        ``q.offer(need);``        ``int` `c = ``0``;` `        ``while` `(!q.isEmpty()) {``            ``int` `s = q.size();``            ` `            ``for` `(``int` `i = ``0``; i < s; i++) {``                ``TreeNode temp = q.poll();``                ``mm.put(temp, ``1``);` `                ``if` `(c == K) {``                    ``ans.add(temp.val);``                ``}` `              ``// moving left``                ``if` `(temp.left != ``null` `&& mm.getOrDefault(temp.left, ``0``) == ``0``) {``                    ``q.offer(temp.left);``                ``}` `             ``// moving right``                ``if` `(temp.right != ``null` `&& mm.getOrDefault(temp.right, ``0``) == ``0``) {``                    ``q.offer(temp.right);``                ``}` `                ``if` `(m.containsKey(temp) && mm.getOrDefault(m.get(temp), ``0``) == ``0``) {``                    ``q.offer(m.get(temp));``                ``}``            ``}` `            ``c++;``            ``if` `(c > K) {``                ``break``;``            ``}``        ``}` `        ``return` `ans;``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``TreeNode root = ``new` `TreeNode(``20``);``        ``root.left = ``new` `TreeNode(``8``);``        ``root.right = ``new` `TreeNode(``22``);``        ``root.left.left = ``new` `TreeNode(``4``);``        ``root.left.right = ``new` `TreeNode(``12``);``        ``root.left.right.left = ``new` `TreeNode(``10``);``        ``root.left.right.right = ``new` `TreeNode(``4``);``        ``TreeNode target = root.left.right;``        ``List result = distanceK(root, target, ``2``);``        ``System.out.print(``"["``);``        ``for` `(``int` `i = ``0``; i < result.size() - ``1``; i++) {``            ``System.out.print(result.get(i) + ``", "``);``        ``}``        ``System.out.println(result.get(result.size() - ``1``) + ``"]"``);``    ``}``}`

## Python3

 `from` `collections ``import` `deque` `class` `TreeNode:``    ``def` `__init__(``self``, val):``        ``self``.val ``=` `val``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `def` `distanceK(root, target, K):``    ``ans ``=` `[]``    ``q ``=` `deque()``    ``q.append(root)``    ``need ``=` `None``    ``m ``=` `{}  ``# to store the parent of each node``    ` `    ``# BFS traversal to find the target node and populate the parent map``    ``while` `q:``        ``s ``=` `len``(q)``        ``for` `i ``in` `range``(s):``            ``temp ``=` `q.popleft()``            ``if` `temp ``=``=` `target:``                ``need ``=` `temp  ``# found the target node``            ` `            ``if` `temp.left:``                ``q.append(temp.left)``                ``m[temp.left] ``=` `temp  ``# map the parent of the left child``            ` `            ``if` `temp.right:``                ``q.append(temp.right)``                ``m[temp.right] ``=` `temp  ``# map the parent of the right child``    ` `    ``mm ``=` `{}  ``# to store whether a node has been visited or not``    ``q.append(need)``    ``c ``=` `0`  `# current distance from the target node``    ` `    ``# BFS traversal to find nodes at distance K from the target node``    ``while` `q:``        ``s ``=` `len``(q)``        ``for` `i ``in` `range``(s):``            ``temp ``=` `q.popleft()``            ``mm[temp] ``=` `1`  `# mark the current node as visited``            ` `            ``if` `c ``=``=` `K:``                ``ans.append(temp.val)  ``# add the node value to the result if it's at distance K``            ` `            ``if` `temp.left ``and` `mm.get(temp.left, ``0``) ``=``=` `0``:``                ``q.append(temp.left)  ``# move left if the left child is not visited``            ` `            ``if` `temp.right ``and` `mm.get(temp.right, ``0``) ``=``=` `0``:``                ``q.append(temp.right)  ``# move right if the right child is not visited``            ` `            ``if` `m.get(temp) ``and` `mm.get(m[temp], ``0``) ``=``=` `0``:``                ``q.append(m[temp])  ``# move to the parent if the parent is not visited``        ` `        ``c ``+``=` `1``        ``if` `c > K:``            ``break`  `# break if the current distance exceeds K (no need to go further)``    ` `    ``return` `ans` `# driver program to test the above functions``if` `__name__ ``=``=` `"__main__"``:``    ``root ``=` `TreeNode(``20``)``    ``root.left ``=` `TreeNode(``8``)``    ``root.right ``=` `TreeNode(``22``)``    ``root.left.left ``=` `TreeNode(``4``)``    ``root.left.right ``=` `TreeNode(``12``)``    ``root.left.right.left ``=` `TreeNode(``10``)``    ``root.left.right.right ``=` `TreeNode(``14``)``    ``target ``=` `root.left.right``    ``result ``=` `distanceK(root, target, ``2``)``    ``print``(result)  ``# Output: [4, 20]`

## C#

 `using` `System;``using` `System.Collections.Generic;` `// Creating tree node``public` `class` `TreeNode``{``    ``public` `int` `Val;``    ``public` `TreeNode Left;``    ``public` `TreeNode Right;` `    ``public` `TreeNode(``int` `val)``    ``{``        ``Val = val;``        ``Left = ``null``;``        ``Right = ``null``;``    ``}``}` `public` `class` `MainClass``{``    ``// Finding all the nodes at a distance k from target``    ``public` `static` `List<``int``> DistanceK(TreeNode root, TreeNode target, ``int` `K)``    ``{``        ``// List for answer storing``        ``List<``int``> ans = ``new` `List<``int``>();` `        ``// Queue for BFS``        ``Queue q = ``new` `Queue();``        ``q.Enqueue(root);` `        ``TreeNode need = ``null``;` `        ``// Dictionary to store parent of each node``        ``Dictionary m = ``new` `Dictionary();` `        ``while` `(q.Count > 0)``        ``{``            ``int` `s = q.Count;` `            ``// Traversing the current level``            ``for` `(``int` `i = 0; i < s; i++)``            ``{``                ``TreeNode temp = q.Dequeue();` `                ``// If target found then``                ``if` `(temp == target)``                ``{``                    ``need = temp;``                ``}` `                ``if` `(temp.Left != ``null``)``                ``{``                    ``q.Enqueue(temp.Left);``                    ``m[temp.Left] = temp;``                ``}` `                ``if` `(temp.Right != ``null``)``                ``{``                    ``q.Enqueue(temp.Right);``                    ``m[temp.Right] = temp;``                ``}``            ``}``        ``}` `        ``// Dictionary to store occurrence of a node``        ``// that is, the node has been visited or not``        ``Dictionary mm = ``new` `Dictionary();``        ``q.Enqueue(need);``        ``int` `c = 0;` `        ``while` `(q.Count > 0)``        ``{``            ``int` `s = q.Count;` `            ``for` `(``int` `i = 0; i < s; i++)``            ``{``                ``TreeNode temp = q.Dequeue();``                ``mm[temp] = 1;` `                ``if` `(c == K)``                ``{``                    ``ans.Add(temp.Val);``                ``}` `                ``// Moving left``                ``if` `(temp.Left != ``null` `&& mm.GetValueOrDefault(temp.Left, 0) == 0)``                ``{``                    ``q.Enqueue(temp.Left);``                ``}` `                ``// Moving right``                ``if` `(temp.Right != ``null` `&& mm.GetValueOrDefault(temp.Right, 0) == 0)``                ``{``                    ``q.Enqueue(temp.Right);``                ``}` `                ``if` `(m.ContainsKey(temp) && mm.GetValueOrDefault(m[temp], 0) == 0)``                ``{``                    ``q.Enqueue(m[temp]);``                ``}``            ``}` `            ``c++;``            ``if` `(c > K)``            ``{``                ``break``;``            ``}``        ``}` `        ``return` `ans;``    ``}` `    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``TreeNode root = ``new` `TreeNode(20);``        ``root.Left = ``new` `TreeNode(8);``        ``root.Right = ``new` `TreeNode(22);``        ``root.Left.Left = ``new` `TreeNode(4);``        ``root.Left.Right = ``new` `TreeNode(12);``        ``root.Left.Right.Left = ``new` `TreeNode(10);``        ``root.Left.Right.Right = ``new` `TreeNode(14);``        ``TreeNode target = root.Left.Right;``        ``List<``int``> result = DistanceK(root, target, 2);``        ``Console.Write(``"["``);``        ``for` `(``int` `i = 0; i < result.Count - 1; i++)``        ``{``            ``Console.Write(result[i] + ``", "``);``        ``}``        ``Console.WriteLine(result[result.Count - 1] + ``"]"``);``    ``}``}`

## Javascript

 `// JavaScript Program for the above approach``// A binary tree node structure``class TreeNode {``    ``constructor(val) {``        ``this``.val = val;``        ``this``.left = ``null``;``        ``this``.right = ``null``;``    ``}``}` `// finding all the nodes at a distance k from target``function` `distanceK(root, target, K) {``    ``// vector to store answer``    ``let ans = [];``  ` `    ``// queue for bfs``    ``let q = [];``  ` `    ``q.push(root);``  ` `    ``// to store target node``    ``let need;``  ` `    ``// map to store parent of each node``    ``let m = ``new` `Map();``  ` `    ``// bfs``    ``while` `(q.length) {``        ``let s = q.length;``    ` `        ``// traversing the current level``        ``for` `(let i = 0; i < s; i++) {``            ``let temp = q.shift();``      ` `            ``// if target value found``            ``if` `(temp === target) {``                ``need = temp;``            ``}``      ` `            ``if` `(temp.left) {``                ``q.push(temp.left);``                ``m.set(temp.left, temp);``            ``}``      ` `            ``if` `(temp.right) {``                ``q.push(temp.right);``                ``m.set(temp.right, temp);``            ``}``        ``}``    ``}``  ` `    ``// map to store occurrence of a node``    ``// that is whether the node has been taken or not``    ``let mm = ``new` `Map();``  ` `    ``q.push(need);``  ` `    ``// to store current distance``    ``let c = 0;``  ` `    ``while` `(q.length) {``        ``let s = q.length;``    ` `        ``for` `(let i = 0; i < s; i++) {``            ``let temp = q.shift();``      ` `            ``mm.set(temp, 1);``      ` `            ``if` `(c === K) {``                ``ans.push(temp.val);``            ``}``      ` `            ``// moving left``            ``if` `(temp.left && !mm.has(temp.left)) {``                ``q.push(temp.left);``            ``}``      ` `            ``// moving right``            ``if` `(temp.right && !mm.has(temp.right)) {``                ``q.push(temp.right);``            ``}``      ` `            ``// moving to parent``            ``if` `(m.get(temp) && !mm.has(m.get(temp))) {``                ``q.push(m.get(temp));``            ``}``        ``}``    ` `        ``c++;``        ``if` `(c > K) {``            ``break``;``        ``}``    ``}``  ` `    ``return` `ans;``}` `// driver program to test the above functions``let root = ``new` `TreeNode(20);``root.left = ``new` `TreeNode(8);``root.right = ``new` `TreeNode(22);``root.left.left = ``new` `TreeNode(4);``root.left.right = ``new` `TreeNode(12);``root.left.right.left = ``new` `TreeNode(10);``root.left.right.right = ``new` `TreeNode(14);``let target = root.left.right;``let result = distanceK(root, target, 2);``console.log(result);``// THIS CODE IS CONTRIBUTED BY YASH AGARWAL(YASHAGARWAL2852002)`

Output
```[4, 20]

```

Time Complexity:- O(N)
Space Complexity:- O(N)

Previous
Next