 Open in App
Not now

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

• Difficulty Level : Hard
• Last Updated : 01 Dec, 2022

Given a Binary Tree and a positive integer K, print all nodes that are distance K from a leaf node. Here K distance from a leaf means K levels higher than a leaf node. For example, if K is more than the height of the Binary Tree, then nothing should be printed.

Examples: Recommended Practice

Approach: To solve the problem follow the below idea:

We can store the nodes in the path of our recursion and whenever we reach a leaf node, then print the Kth node in the saved path

Follow the below steps to solve the problem:

• Traverse the tree and keep storing all ancestors till we hit a leaf node.
• When we reach a leaf node, we print the ancestor at distance K using the values stored in the array.
• We also need to keep track of nodes that are already printed as output. For that, we use a boolean array visited[]

Below is the implementation of the above approach:

## C++

 `/* 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 number 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 code*/``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 number 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 code``    ``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.print(``" 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 number 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 number 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.Write(``" Nodes at distance 2 are : "``);``        ``tree.printKDistantfromLeaf(tree.root, 2);``    ``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output

`Nodes at distance 2 are: 1 3 `

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

My Personal Notes arrow_drop_up