# Print all nodes that are at distance k from a leaf node

Given a Binary Tree and a positive integer k, print all nodes that are distance k from a leaf node.

Here the meaning of distance is different from previous post. Here k distance from a leaf means k levels higher than a leaf node. For example if k is more than height of Binary Tree, then nothing should be printed. Expected time complexity is O(n) where n is the number nodes in the given Binary Tree. ## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

The idea is to traverse the tree. Keep storing all ancestors till we hit a leaf node. When we reach a leaf node, we print the ancestor at distance k. We also need to keep track of nodes that are already printed as output. For that we use a boolean array visited[].

## C++

 `/* Program to print all nodes which are at distance k from a leaf */` `#include ` `using` `namespace` `std; ` `#define MAX_HEIGHT 10000 ` ` `  `struct` `Node ` `{ ` `    ``int` `key; ` `    ``Node *left, *right; ` `}; ` ` `  `/* utility that allocates a new Node with the given key  */` `Node* newNode(``int` `key) ` `{ ` `    ``Node* node = ``new` `Node; ` `    ``node->key = key; ` `    ``node->left = node->right = NULL; ` `    ``return` `(node); ` `} ` ` `  `/* This function prints all nodes that are distance k from a leaf node ` `   ``path[] --> Store ancestors of a node ` `   ``visited[] --> Stores true if a node is printed as output.  A node may be k ` `                 ``distance away from many leaves, we want to print it once */` `void` `kDistantFromLeafUtil(Node* node, ``int` `path[], ``bool` `visited[], ` `                          ``int` `pathLen, ``int` `k) ` `{ ` `    ``// Base case ` `    ``if` `(node==NULL) ``return``; ` ` `  `    ``/* append this Node to the path array */` `    ``path[pathLen] = node->key; ` `    ``visited[pathLen] = ``false``; ` `    ``pathLen++; ` ` `  `    ``/* it's a leaf, so print the ancestor at distance k only ` `       ``if the ancestor is not already printed  */` `    ``if` `(node->left == NULL && node->right == NULL && ` `        ``pathLen-k-1 >= 0 && visited[pathLen-k-1] == ``false``) ` `    ``{ ` `        ``cout << path[pathLen-k-1] << ``" "``; ` `        ``visited[pathLen-k-1] = ``true``; ` `        ``return``; ` `    ``} ` ` `  `    ``/* If not leaf node, recur for left and right subtrees */` `    ``kDistantFromLeafUtil(node->left, path, visited, pathLen, k); ` `    ``kDistantFromLeafUtil(node->right, path, visited, pathLen, k); ` `} ` ` `  `/* Given a binary tree and a nuber k, print all nodes that are k ` `   ``distant from a leaf*/` `void` `printKDistantfromLeaf(Node* node, ``int` `k) ` `{ ` `    ``int` `path[MAX_HEIGHT]; ` `    ``bool` `visited[MAX_HEIGHT] = {``false``}; ` `    ``kDistantFromLeafUtil(node, path, visited, 0, k); ` `} ` ` `  `/* Driver program to test above functions*/` `int` `main() ` `{ ` `    ``// Let us create binary tree given in the above example ` `    ``Node * root = newNode(1); ` `    ``root->left = newNode(2); ` `    ``root->right = newNode(3); ` `    ``root->left->left = newNode(4); ` `    ``root->left->right = newNode(5); ` `    ``root->right->left = newNode(6); ` `    ``root->right->right = newNode(7); ` `    ``root->right->left->right = newNode(8); ` ` `  `    ``cout << ``"Nodes at distance 2 are: "``; ` `    ``printKDistantfromLeaf(root, 2); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to print all nodes at a distance k from leaf ` `// A binary tree node ` `class` `Node ` `{ ` `    ``int` `data; ` `    ``Node left, right; ` `  `  `    ``Node(``int` `item) ` `    ``{ ` `        ``data = item; ` `        ``left = right = ``null``; ` `    ``} ` `} ` `  `  `class` `BinaryTree ` `{ ` `    ``Node root; ` `  `  `    ``/* This function prints all nodes that are distance k from a leaf node ` `     ``path[] --> Store ancestors of a node ` `     ``visited[] --> Stores true if a node is printed as output.  A node may ` `     ``be k distance away from many leaves, we want to print it once */` `    ``void` `kDistantFromLeafUtil(Node node, ``int` `path[], ``boolean` `visited[], ` `                              ``int` `pathLen, ``int` `k) ` `    ``{ ` `        ``// Base case ` `        ``if` `(node == ``null``) ` `            ``return``; ` `  `  `        ``/* append this Node to the path array */` `        ``path[pathLen] = node.data; ` `        ``visited[pathLen] = ``false``; ` `        ``pathLen++; ` `  `  `        ``/* it's a leaf, so print the ancestor at distance k only ` `         ``if the ancestor is not already printed  */` `        ``if` `(node.left == ``null` `&& node.right == ``null` `           ``&& pathLen - k - ``1` `>= ``0` `&& visited[pathLen - k - ``1``] == ``false``) ` `        ``{ ` `            ``System.out.print(path[pathLen - k - ``1``] + ``" "``); ` `            ``visited[pathLen - k - ``1``] = ``true``; ` `            ``return``; ` `        ``} ` `  `  `        ``/* If not leaf node, recur for left and right subtrees */` `        ``kDistantFromLeafUtil(node.left, path, visited, pathLen, k); ` `        ``kDistantFromLeafUtil(node.right, path, visited, pathLen, k); ` `    ``} ` `  `  `    ``/* Given a binary tree and a nuber k, print all nodes that are k ` `     ``distant from a leaf*/` `    ``void` `printKDistantfromLeaf(Node node, ``int` `k) ` `    ``{ ` `        ``int` `path[] = ``new` `int``[``1000``]; ` `        ``boolean` `visited[] = ``new` `boolean``[``1000``]; ` `        ``kDistantFromLeafUtil(node, path, visited, ``0``, k); ` `    ``} ` `  `  `    ``// 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(``1``); ` `        ``tree.root.left = ``new` `Node(``2``); ` `        ``tree.root.right = ``new` `Node(``3``); ` `        ``tree.root.left.left = ``new` `Node(``4``); ` `        ``tree.root.left.right = ``new` `Node(``5``); ` `        ``tree.root.right.left = ``new` `Node(``6``); ` `        ``tree.root.right.right = ``new` `Node(``7``); ` `        ``tree.root.right.left.right = ``new` `Node(``8``); ` `  `  `        ``System.out.println(``" Nodes at distance 2 are :"``); ` `        ``tree.printKDistantfromLeaf(tree.root, ``2``); ` `    ``} ` `} ` `  `  `// This code has been contributed by Mayank Jaiswal `

## Python3

 `# Program to print all nodes which are at  ` `# distance k from a leaf  ` ` `  `# utility that allocates a new Node with  ` `# the given key  ` `class` `newNode: ` `    ``def` `__init__(``self``, key): ` `        ``self``.key ``=` `key  ` `        ``self``.left ``=` `self``.right ``=` `None` ` `  `# This function prints all nodes that  ` `# are distance k from a leaf node  ` `# path[] -. Store ancestors of a node  ` `# visited[] -. Stores true if a node is  ` `# printed as output. A node may be k distance  ` `# away from many leaves, we want to print it once  ` `def` `kDistantFromLeafUtil(node, path, visited,  ` `                                 ``pathLen, k): ` `     `  `    ``# Base case  ` `    ``if` `(node ``=``=` `None``): ` `        ``return` ` `  `    ``# append this Node to the path array ` `    ``path[pathLen] ``=` `node.key  ` `    ``visited[pathLen] ``=` `False` `    ``pathLen ``+``=` `1` ` `  `    ``# it's a leaf, so print the ancestor at  ` `    ``# distance k only if the ancestor is  ` `    ``# not already printed  ` `    ``if` `(node.left ``=``=` `None` `and` `node.right ``=``=` `None` `and`  `                            ``pathLen ``-` `k ``-` `1` `>``=` `0` `and`  `                            ``visited[pathLen ``-` `k ``-` `1``] ``=``=` `False``): ` `        ``print``(path[pathLen ``-` `k ``-` `1``], end ``=` `" "``)  ` `        ``visited[pathLen ``-` `k ``-` `1``] ``=` `True` `        ``return` ` `  `    ``# If not leaf node, recur for left  ` `    ``# and right subtrees  ` `    ``kDistantFromLeafUtil(node.left, path,  ` `                         ``visited, pathLen, k) ` `    ``kDistantFromLeafUtil(node.right, path,  ` `                         ``visited, pathLen, k) ` ` `  `# Given a binary tree and a nuber k,  ` `# print all nodes that are k distant from a leaf ` `def` `printKDistantfromLeaf(node, k): ` `    ``global` `MAX_HEIGHT ` `    ``path ``=` `[``None``] ``*` `MAX_HEIGHT  ` `    ``visited ``=` `[``False``] ``*` `MAX_HEIGHT ` `    ``kDistantFromLeafUtil(node, path, visited, ``0``, k) ` ` `  `# Driver Code ` `MAX_HEIGHT ``=` `10000` ` `  `# Let us create binary tree given in  ` `# the above example  ` `root ``=` `newNode(``1``)  ` `root.left ``=` `newNode(``2``)  ` `root.right ``=` `newNode(``3``)  ` `root.left.left ``=` `newNode(``4``)  ` `root.left.right ``=` `newNode(``5``)  ` `root.right.left ``=` `newNode(``6``)  ` `root.right.right ``=` `newNode(``7``)  ` `root.right.left.right ``=` `newNode(``8``)  ` ` `  `print``(``"Nodes at distance 2 are:"``, end ``=` `" "``)  ` `printKDistantfromLeaf(root, ``2``) ` ` `  `# This code is contributed by pranchalK `

## C#

 `using` `System; ` ` `  `// C# program to print all nodes at a distance k from leaf  ` `// 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; ` ` `  `    ``/* This function prints all nodes that are distance k from a leaf node  ` `     ``path[] --> Store ancestors of a node  ` `     ``visited[] --> Stores true if a node is printed as output.  A node may  ` `     ``be k distance away from many leaves, we want to print it once */` `    ``public` `virtual` `void` `kDistantFromLeafUtil(Node node, ``int``[] path, ``bool``[] visited, ``int` `pathLen, ``int` `k) ` `    ``{ ` `        ``// Base case  ` `        ``if` `(node == ``null``) ` `        ``{ ` `            ``return``; ` `        ``} ` ` `  `        ``/* append this Node to the path array */` `        ``path[pathLen] = node.data; ` `        ``visited[pathLen] = ``false``; ` `        ``pathLen++; ` ` `  `        ``/* it's a leaf, so print the ancestor at distance k only  ` `         ``if the ancestor is not already printed  */` `        ``if` `(node.left == ``null` `&& node.right == ``null` `&& pathLen - k - 1 >= 0 && visited[pathLen - k - 1] == ``false``) ` `        ``{ ` `            ``Console.Write(path[pathLen - k - 1] + ``" "``); ` `            ``visited[pathLen - k - 1] = ``true``; ` `            ``return``; ` `        ``} ` ` `  `        ``/* If not leaf node, recur for left and right subtrees */` `        ``kDistantFromLeafUtil(node.left, path, visited, pathLen, k); ` `        ``kDistantFromLeafUtil(node.right, path, visited, pathLen, k); ` `    ``} ` ` `  `    ``/* Given a binary tree and a nuber k, print all nodes that are k  ` `     ``distant from a leaf*/` `    ``public` `virtual` `void` `printKDistantfromLeaf(Node node, ``int` `k) ` `    ``{ ` `        ``int``[] path = ``new` `int``; ` `        ``bool``[] visited = ``new` `bool``; ` `        ``kDistantFromLeafUtil(node, path, visited, 0, k); ` `    ``} ` ` `  `    ``// 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(1); ` `        ``tree.root.left = ``new` `Node(2); ` `        ``tree.root.right = ``new` `Node(3); ` `        ``tree.root.left.left = ``new` `Node(4); ` `        ``tree.root.left.right = ``new` `Node(5); ` `        ``tree.root.right.left = ``new` `Node(6); ` `        ``tree.root.right.right = ``new` `Node(7); ` `        ``tree.root.right.left.right = ``new` `Node(8); ` ` `  `        ``Console.WriteLine(``" Nodes at distance 2 are :"``); ` `        ``tree.printKDistantfromLeaf(tree.root, 2); ` `    ``} ` `} ` ` `  `// This code is contributed by Shrikant13 `

Output:

`Nodes at distance 2 are: 1 3 `

Time Complexity: Time Complexity of above code is O(n) as the code does a simple tree traversal.