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.
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 <iostream> 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; } |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
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[1000]; bool[] visited = new bool[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); Console.WriteLine(" Nodes at distance 2 are :"); tree.printKDistantfromLeaf(tree.root, 2); } } // This code is contributed by Shrikant13 |
chevron_right
filter_none
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.
Space Optimized Solution :
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; /* Given a binary tree and a nuber k, print all nodes that are k distant from a leaf*/ int printKDistantfromLeaf(Node node, int k) { if (node == null) return -1; int lk = printKDistantfromLeaf(node.left, k); int rk = printKDistantfromLeaf(node.right, k); boolean isLeaf = lk == -1 && lk == rk; if (lk == 0 || rk == 0 || (isLeaf && k == 0)) System.out.print(" " + node.data); if (isLeaf && k > 0) return k - 1; // leaf node if (lk > 0 && lk < k) return lk - 1; // parent of left leaf if (rk > 0 && rk < k) return rk - 1; // parent of right leaf return -2; } // 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 Vijayan Annamalai |
chevron_right
filter_none
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
Recommended Posts:
- Print the nodes that are just above the leaf node
- Print the nodes of binary tree as they become the leaf node
- Print all nodes at distance k from a given node
- Print all nodes at distance K from given node: Iterative Approach
- Queries to find sum of distance of a given node to every leaf node in a Weighted Tree
- Print Leaf Nodes at a given Level
- Print all leaf nodes of an n-ary tree using DFS
- Sum of nodes on the longest path from root to leaf node
- Number of leaf nodes in the subtree of every node of an n-ary tree
- Print all leaf nodes of a Binary Tree from left to right
- Print all leaf nodes of a binary tree from right to left
- Print Sum and Product of all Non-Leaf nodes in Binary Tree
- Print left and right leaf nodes separately in Binary Tree
- Print leaf nodes in binary tree from left to right using one stack
- Print All Leaf Nodes of a Binary Tree from left to right | Set-2 ( Iterative Approach )
- Implementing a BST where every node stores the maximum number of nodes in the path till any leaf
- Print nodes at k distance from root
- Print nodes at k distance from root | Iterative
- Distance between two nodes of binary tree with node values from 1 to N
- Print the longest leaf to leaf path in a Binary tree
