Print nodes at k distance from root

Given a root of a tree, and an integer k. Print all the nodes which are at k distance from root.

For example, in the below tree, 4, 5 & 8 are at distance 2 from root.

            1
          /   \
        2      3
      /  \    /
    4     5  8 

The problem can be solved using recursion. Thanks to eldho for suggesting the solution.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

#include<bits/stdc++.h> 
  
using namespace std;
  
/* A binary tree node has data,
pointer to left child and
a pointer to right child */
class node 
    public:
    int data; 
    node* left; 
    node* right; 
      
    /* Constructor that allocates a new node with the 
    given data and NULL left and right pointers. */
    node(int data)
    {
        this->data = data;
        this->left = NULL;
        this->right = NULL;
    }
}; 
  
void printKDistant(node *root , int k) 
    if(root == NULL) 
        return
    if( k == 0 ) 
    
        cout << root->data << " "
        return
    
    else
    
        printKDistant( root->left, k - 1 ) ; 
        printKDistant( root->right, k - 1 ) ; 
    
  
  
/* Driver code*/
int main() 
  
    /* Constructed binary tree is 
            
            / \ 
        2     3 
        / \     / 
        4 5 8 
    */
    node *root = new node(1); 
    root->left = new node(2); 
    root->right = new node(3); 
    root->left->left = new node(4); 
    root->left->right = new node(5); 
    root->right->left = new node(8); 
      
    printKDistant(root, 2); 
    return 0; 
  
// This code is contributed by rathbhupendra

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

#include <stdio.h>
#include <stdlib.h>
  
/* A binary tree node has data, pointer to left child
   and a pointer to right child */
struct node
{
   int data;
   struct node* left;
   struct node* right;
};
  
void printKDistant(struct node *root , int k)    
{
   if(root == NULL) 
      return;
   if( k == 0 )
   {
      printf( "%d ", root->data );
      return ;
   }
   else
   {      
      printKDistant( root->left, k-1 ) ;
      printKDistant( root->right, k-1 ) ;
   }
}
  
/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct node* newNode(int data)
{
  struct node* node = (struct node*)
                       malloc(sizeof(struct node));
  node->data = data;
  node->left = NULL;
  node->right = NULL;
  
  return(node);
}
  
/* Driver program to test above functions*/
int main()
{
  
  /* Constructed binary tree is
            1
          /   \
        2      3
      /  \    /
    4     5  8 
  */
  struct 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(8);  
  
  printKDistant(root, 2);
  
  getchar();
  return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to print nodes at k distance from root
   
/* A binary tree node has data, pointer to left child
   and a pointer to right child */
class Node 
{
    int data;
    Node left, right;
   
    Node(int item) 
    {
        data = item;
        left = right = null;
    }
}
   
class BinaryTree 
{
    Node root;
   
    void printKDistant(Node node, int k) 
    {
        if (node == null)
            return;
        if (k == 0
        {
            System.out.print(node.data + " ");
            return;
        
        else 
        {
            printKDistant(node.left, k - 1);
            printKDistant(node.right, k - 1);
        }
    }
      
    /* Driver program to test above functions */
    public static void main(String args[]) {
        BinaryTree tree = new BinaryTree();
          
        /* Constructed binary tree is
                1
              /   \
             2     3
            /  \   /
           4    5 8 
        */
        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(8);
   
        tree.printKDistant(tree.root, 2);
    }
}
   
// This code has been contributed by Mayank Jaiswal

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program to find the nodes at k distance from root
  
# A Binary tree node
class Node:
      
    # Constructor to create a new node
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
  
def printKDistant(root, k):
      
    if root is None:
        return 
    if k == 0:
        print root.data,
    else:
        printKDistant(root.left, k-1)
        printKDistant(root.right, k-1)
  
# Driver program to test above function
"""
   Constructed binary tree is
            1
          /   \
        2      3
      /  \    /
    4     5  8 
"""
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
root.right.left = Node(8)
  
printKDistant(root, 2)
  
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

using System;
  
// c# program to print nodes at k distance from root 
  
/* A binary tree node has data, pointer to left child 
   and a pointer to right child */
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;
  
    public virtual void printKDistant(Node node, int k)
    {
        if (node == null)
        {
            return;
        }
        if (k == 0)
        {
            Console.Write(node.data + " ");
            return;
        }
        else
        {
            printKDistant(node.left, k - 1);
            printKDistant(node.right, k - 1);
        }
    }
  
    /* Driver program to test above functions */
    public static void Main(string[] args)
    {
        BinaryTree tree = new BinaryTree();
  
        /* Constructed binary tree is 
                
              /   \ 
             2     3 
            /  \   / 
           4    5 8  
        */
        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(8);
  
        tree.printKDistant(tree.root, 2);
    }
}
  
// This code is contributed by Shrikant13

chevron_right



Output:

4 5 8 

Time Complexity: O(n) where n is number of nodes in the given binary tree.

Please write comments if you find the above code/algorithm incorrect, or find better ways to solve the same problem.

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.




My Personal Notes arrow_drop_up

Improved By : shrikanth13, rathbhupendra