Posted on by Kalkicode
Code Hash

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

Here given code implementation process.

``````import java.util.HashSet;
import java.util.ArrayList;
/*
Java Program
Print all nodes that are at distance k from a leaf node
*/
// Binary Tree node
class TreeNode
{
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
public class BinaryTree
{
public TreeNode root;
public BinaryTree()
{
// Set initial value
this.root = null;
}
public void findResult(TreeNode node,
HashSet < TreeNode > result,
ArrayList < TreeNode > path, int k)
{
if (node != null)
{
if (node.left == null && node.right == null)
{
if (path.size() >= k)
{
}
return;
}
//  Visit left and right subtree using recursively
findResult(node.left, result, path, k);
findResult(node.right, result, path, k);
// Remove last node in path
path.remove(path.size() - 1);
}
}
//  Handles the request of finding kth from left node to root
public void distanceKfromLeft(int k)
{
if (k < 0)
{
return;
}
// This is used to collect unique result
HashSet < TreeNode > result = new HashSet < TreeNode > ();
// This is used to track the path from root to leaf node
ArrayList < TreeNode > path = new ArrayList < TreeNode > ();
// Find nodes
findResult(this.root, result, path, k);
System.out.println("\n Given K " + k);
if (result.size() == 0)
{
// When result not exists
System.out.print(" No result \n");
}
else
{
// Display calculated result
for (TreeNode node: result)
{
System.out.print("  " + node.data);
}
}
}
public static void main(String[] args)
{
BinaryTree tree = new BinaryTree();
/*
Binary Tree
------------
10
/    \
-2     5
/ \    /  \
1   3  7    2
/    \    \
9      8    4
/
11
*/
tree.root = new TreeNode(10);
tree.root.left = new TreeNode(-2);
tree.root.right = new TreeNode(5);
tree.root.right.right = new TreeNode(2);
tree.root.right.right.right = new TreeNode(4);
tree.root.right.left = new TreeNode(7);
tree.root.right.left.right = new TreeNode(8);
tree.root.left.left = new TreeNode(1);
tree.root.left.right = new TreeNode(3);
tree.root.left.right.left = new TreeNode(9);
tree.root.right.left.right.left = new TreeNode(11);
// Test A
// K = 2
tree.distanceKfromLeft(2);
// Test B
// K = 4
tree.distanceKfromLeft(4);
// Test C
// K = 1
tree.distanceKfromLeft(1);
// Test D
// K = 3
tree.distanceKfromLeft(3);
}
}``````

#### Output

`````` Given K 2
5  10  -2  7
Given K 4
10
Given K 1
2  8  -2  3
Given K 3
5  10``````
``````// Include header file
#include <iostream>
#include <set>
#include <vector>

using namespace std;
/*
C++ Program
Print all nodes that are at distance k from a leaf node
*/
// Binary Tree node
class TreeNode
{
public: int data;
TreeNode *left;
TreeNode *right;
TreeNode(int data)
{
// Set node value
this->data = data;
this->left = NULL;
this->right = NULL;
}
};
class BinaryTree
{
public: TreeNode *root;
BinaryTree()
{
this->root = NULL;
}
void findResult(TreeNode *node,
set < TreeNode*> &result,
vector < TreeNode *> &path, int k)
{
if (node != NULL)
{
if (node->left == NULL && node->right == NULL)
{
if (path.size() >= k)
{
result.insert(path.at(path.size() - k));
}
return;
}
path.push_back(node);
//  Visit left and right subtree using recursively
this->findResult(node->left, result, path, k);
this->findResult(node->right, result, path, k);
// Remove last node in path
path.pop_back();
}
}
//  Handles the request of finding kth from left node to root
void distanceKfromLeft(int k)
{
if (k < 0)
{
return;
}
// This is used to collect unique result
set < TreeNode *> result;
// This is used to track the path from root to leaf node
vector < TreeNode *> path;
// Find nodes
this->findResult(this->root, result, path, k);
cout << "\n Given K " << k << endl;
if (result.size() == 0)
{
// When result not exists
cout << " No result \n";
}
else
{
// Display calculated result
for (auto &v : result)
{
cout << "  " << v->data;
}
}
}
};
int main()
{
BinaryTree *tree = new BinaryTree();
/*
Binary Tree
------------
10
/    \
-2     5
/ \    /  \
1   3  7    2
/    \    \
9      8    4
/
11
*/
tree->root = new TreeNode(10);
tree->root->left = new TreeNode(-2);
tree->root->right = new TreeNode(5);
tree->root->right->right = new TreeNode(2);
tree->root->right->right->right = new TreeNode(4);
tree->root->right->left = new TreeNode(7);
tree->root->right->left->right = new TreeNode(8);
tree->root->left->left = new TreeNode(1);
tree->root->left->right = new TreeNode(3);
tree->root->left->right->left = new TreeNode(9);
tree->root->right->left->right->left = new TreeNode(11);
// Test A
// K = 2
tree->distanceKfromLeft(2);
// Test B
// K = 4
tree->distanceKfromLeft(4);
// Test C
// K = 1
tree->distanceKfromLeft(1);
// Test D
// K = 3
tree->distanceKfromLeft(3);
return 0;
}``````

#### Output

`````` Given K 2
10  -2  5  7
Given K 4
10
Given K 1
-2  2  8  3
Given K 3
10  5``````
``````// Include namespace system
using System;
using System.Collections.Generic;
/*
Csharp Program
Print all nodes that are at distance k from a leaf node
*/
// Binary Tree node
public class TreeNode
{
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
public class BinaryTree
{
public TreeNode root;
public BinaryTree()
{
// Set initial value
this.root = null;
}
public void findResult(TreeNode node,
HashSet < TreeNode > result,
List < TreeNode > path, int k)
{
if (node != null)
{
if (node.left == null && node.right == null)
{
if (path.Count >= k)
{
}
return;
}
//  Visit left and right subtree using recursively
this.findResult(node.left, result, path, k);
this.findResult(node.right, result, path, k);
// Remove last node in path
path.RemoveAt(path.Count - 1);
}
}
//  Handles the request of finding kth from left node to root
public void distanceKfromLeft(int k)
{
if (k < 0)
{
return;
}
// This is used to collect unique result
HashSet < TreeNode > result = new HashSet < TreeNode > ();
// This is used to track the path from root to leaf node
List < TreeNode > path = new List < TreeNode > ();
// Find nodes
this.findResult(this.root, result, path, k);
Console.WriteLine("\n Given K " + k);
if (result.Count == 0)
{
// When result not exists
Console.Write(" No result \n");
}
else
{
// Display calculated result
foreach(TreeNode node in result)
{
Console.Write("  " + node.data);
}
}
}
public static void Main(String[] args)
{
BinaryTree tree = new BinaryTree();
/*
Binary Tree
------------
10
/    \
-2     5
/ \    /  \
1   3  7    2
/    \    \
9      8    4
/
11
*/
tree.root = new TreeNode(10);
tree.root.left = new TreeNode(-2);
tree.root.right = new TreeNode(5);
tree.root.right.right = new TreeNode(2);
tree.root.right.right.right = new TreeNode(4);
tree.root.right.left = new TreeNode(7);
tree.root.right.left.right = new TreeNode(8);
tree.root.left.left = new TreeNode(1);
tree.root.left.right = new TreeNode(3);
tree.root.left.right.left = new TreeNode(9);
tree.root.right.left.right.left = new TreeNode(11);
// Test A
// K = 2
tree.distanceKfromLeft(2);
// Test B
// K = 4
tree.distanceKfromLeft(4);
// Test C
// K = 1
tree.distanceKfromLeft(1);
// Test D
// K = 3
tree.distanceKfromLeft(3);
}
}``````

#### Output

`````` Given K 2
10  -2  7  5
Given K 4
10
Given K 1
-2  3  8  2
Given K 3
10  5``````
``````package main
import "fmt"
/*
Go Program
Print all nodes that are at distance k from a leaf node
*/
// Binary Tree node
type TreeNode struct {
data int
left * TreeNode
right * TreeNode
}
func getTreeNode(data int) * TreeNode {
var me *TreeNode = &TreeNode {}
// Set node value
me.data = data
me.left = nil
me.right = nil
return me
}
type BinaryTree struct {
root * TreeNode
}
func getBinaryTree() * BinaryTree {
var me *BinaryTree = &BinaryTree {}
// Set initial value
me.root = nil
return me
}
func(this BinaryTree) findResult(node * TreeNode,
result map[*TreeNode] bool, path [] *TreeNode , k int) {
if node != nil {
if node.left == nil && node.right == nil {
if len(path) >= k {
result[path[len(path) - k]] = true
}
return
}
path = append(path, node)
//  Visit left and right subtree using recursively
this.findResult(node.left, result, path, k)
this.findResult(node.right, result, path, k)
// Remove last node in path
path = append(path[: len(path) - 1], path[len(path) - 1 + 1: ]...)
}
}
//  Handles the request of finding kth from left node to root
func(this BinaryTree) distanceKfromLeft(k int) {
if k < 0 {
return
}
// This is used to collect unique result
var result = make(map[*TreeNode] bool)
// This is used to track the path from root to leaf node
var path = make([] *TreeNode, 0)
// Find nodes
this.findResult(this.root, result, path, k)
fmt.Println("\n Given K ", k)
if len(result) == 0 {
// When result not exists
fmt.Print(" No result \n")
} else {
// Display calculated result
for node := range result {
fmt.Print("  ", node.data)
}
}
}
func main() {
var tree * BinaryTree = getBinaryTree()
/*
Binary Tree
------------
10
/    \
-2     5
/ \    /  \
1   3  7    2
/    \    \
9      8    4
/
11
*/
tree.root = getTreeNode(10)
tree.root.left = getTreeNode(-2)
tree.root.right = getTreeNode(5)
tree.root.right.right = getTreeNode(2)
tree.root.right.right.right = getTreeNode(4)
tree.root.right.left = getTreeNode(7)
tree.root.right.left.right = getTreeNode(8)
tree.root.left.left = getTreeNode(1)
tree.root.left.right = getTreeNode(3)
tree.root.left.right.left = getTreeNode(9)
tree.root.right.left.right.left = getTreeNode(11)
// Test A
// K = 2
tree.distanceKfromLeft(2)
// Test B
// K = 4
tree.distanceKfromLeft(4)
// Test C
// K = 1
tree.distanceKfromLeft(1)
// Test D
// K = 3
tree.distanceKfromLeft(3)
}``````

#### Output

`````` Given K 2
10  -2  7  5
Given K 4
10
Given K 1
-2  3  8  2
Given K 3
10  5``````
``````<?php
/*
Php Program
Print all nodes that are at distance k from a leaf node
*/
// Binary Tree node
class TreeNode
{
public \$data;
public \$left;
public \$right;
public	function __construct(\$data)
{
// Set node value
\$this->data = \$data;
\$this->left = NULL;
\$this->right = NULL;
}
}
class BinaryTree
{
public \$root;
public	function __construct()
{
\$this->root = NULL;
}
public	function findResult(\$node, &\$result, &\$path, \$k)
{
if (\$node != NULL)
{
if (\$node->left == NULL && \$node->right == NULL)
{
if (count(\$path) >= \$k)
{
if (in_array(\$path[count(\$path) - \$k], \$result) == False)
{
\$result[] = \$path[count(\$path) - \$k];
}
}
return;
}
\$path[] = \$node;
//  Visit left and right subtree using recursively
\$this->findResult(\$node->left, \$result, \$path, \$k);
\$this->findResult(\$node->right, \$result, \$path, \$k);
// Remove last node in path
array_pop(\$path);
}
}
//  Handles the request of finding kth from left node to root
public	function distanceKfromLeft(\$k)
{
if (\$k < 0)
{
return;
}
// This is used to collect unique result
\$result = array();
// This is used to track the path from root to leaf node
\$path = array();
// Find nodes
\$this->findResult(\$this->root, \$result, \$path, \$k);
echo("\n Given K ".\$k.
"\n");
if (count(\$result) == 0)
{
// When result not exists
echo(" No result \n");
}
else
{
// Display calculated result
foreach(\$result as \$p => \$node)
{
echo("  ".\$node->data);
}
}
}
}

function main()
{
\$tree = new BinaryTree();
/*
Binary Tree
------------
10
/    \
-2     5
/ \    /  \
1   3  7    2
/    \    \
9      8    4
/
11
*/
\$tree->root = new TreeNode(10);
\$tree->root->left = new TreeNode(-2);
\$tree->root->right = new TreeNode(5);
\$tree->root->right->right = new TreeNode(2);
\$tree->root->right->right->right = new TreeNode(4);
\$tree->root->right->left = new TreeNode(7);
\$tree->root->right->left->right = new TreeNode(8);
\$tree->root->left->left = new TreeNode(1);
\$tree->root->left->right = new TreeNode(3);
\$tree->root->left->right->left = new TreeNode(9);
\$tree->root->right->left->right->left = new TreeNode(11);
// Test A
// K = 2
\$tree->distanceKfromLeft(2);
// Test B
// K = 4
\$tree->distanceKfromLeft(4);
// Test C
// K = 1
\$tree->distanceKfromLeft(1);
// Test D
// K = 3
\$tree->distanceKfromLeft(3);
}
main();``````

#### Output

`````` Given K 2
10  -2  7  5
Given K 4
10
Given K 1
-2  3  8  2
Given K 3
10  5``````
``````/*
Node JS Program
Print all nodes that are at distance k from a leaf node
*/
// Binary Tree node
class TreeNode
{
constructor(data)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
class BinaryTree
{
constructor()
{
this.root = null;
}
findResult(node, result, path, k)
{
if (node != null)
{
if (node.left == null && node.right == null)
{
if (path.length >= k)
{
}
return;
}
path.push(node);
//  Visit left and right subtree using recursively
this.findResult(node.left, result, path, k);
this.findResult(node.right, result, path, k);
// Remove last node in path
path.pop();
}
}
//  Handles the request of finding kth from left node to root
distanceKfromLeft(k)
{
if (k < 0)
{
return;
}
// This is used to collect unique result
var result = new Set();
// This is used to track the path from root to leaf node
var path = [];
// Find nodes
this.findResult(this.root, result, path, k);
console.log("\n Given K " + k);
if (result.size == 0)
{
// When result not exists
process.stdout.write(" No result \n");
}
else
{
// Display calculated result
for (let node of result)
{
process.stdout.write("  " + node.data);
}
}
}
}

function main()
{
var tree = new BinaryTree();
/*
Binary Tree
------------
10
/    \
-2     5
/ \    /  \
1   3  7    2
/    \    \
9      8    4
/
11
*/
tree.root = new TreeNode(10);
tree.root.left = new TreeNode(-2);
tree.root.right = new TreeNode(5);
tree.root.right.right = new TreeNode(2);
tree.root.right.right.right = new TreeNode(4);
tree.root.right.left = new TreeNode(7);
tree.root.right.left.right = new TreeNode(8);
tree.root.left.left = new TreeNode(1);
tree.root.left.right = new TreeNode(3);
tree.root.left.right.left = new TreeNode(9);
tree.root.right.left.right.left = new TreeNode(11);
// Test A
// K = 2
tree.distanceKfromLeft(2);
// Test B
// K = 4
tree.distanceKfromLeft(4);
// Test C
// K = 1
tree.distanceKfromLeft(1);
// Test D
// K = 3
tree.distanceKfromLeft(3);
}
main();``````

#### Output

`````` Given K 2
10  -2  7  5
Given K 4
10
Given K 1
-2  3  8  2
Given K 3
10  5``````
``````#    Python 3 Program
#    Print all nodes that are at distance k from a leaf node

#  Binary Tree node
class TreeNode :
def __init__(self, data) :
#  Set node value
self.data = data
self.left = None
self.right = None

class BinaryTree :
def __init__(self) :
self.root = None

def findResult(self, node, result, path, k) :
if (node != None) :
if (node.left == None and node.right == None) :
if (len(path) >= k) :

return

path.append(node)
#   Visit left and right subtree using recursively
self.findResult(node.left, result, path, k)
self.findResult(node.right, result, path, k)
#  Remove last node in path
del path[len(path) - 1]

#   Handles the request of finding kth from left node to root
def distanceKfromLeft(self, k) :
if (k < 0) :
return

#  This is used to collect unique result
result = set()
#  This is used to track the path from root to leaf node
path = []
#  Find nodes
self.findResult(self.root, result, path, k)
print("\n Given K ", k)
if (len(result) == 0) :
#  When result not exists
print(" No result ")
else :
for node in result :
print("  ", node.data, end = "")

def main() :
tree = BinaryTree()
#    Binary Tree
#    ------------
#         10
#       /    \
#      -2     5
#     / \    /  \
#    1   3  7    2
#       /    \    \
#      9      8    4
#            /
#           11
tree.root = TreeNode(10)
tree.root.left = TreeNode(-2)
tree.root.right = TreeNode(5)
tree.root.right.right = TreeNode(2)
tree.root.right.right.right = TreeNode(4)
tree.root.right.left = TreeNode(7)
tree.root.right.left.right = TreeNode(8)
tree.root.left.left = TreeNode(1)
tree.root.left.right = TreeNode(3)
tree.root.left.right.left = TreeNode(9)
tree.root.right.left.right.left = TreeNode(11)
#  Test A
#  K = 2
tree.distanceKfromLeft(2)
#  Test B
#  K = 4
tree.distanceKfromLeft(4)
#  Test C
#  K = 1
tree.distanceKfromLeft(1)
#  Test D
#  K = 3
tree.distanceKfromLeft(3)

if __name__ == "__main__": main()``````

#### Output

`````` Given K  2
5   10   7   -2
Given K  4
10
Given K  1
3   8   2   -2
Given K  3
5   10``````
``````#    Ruby Program
#    Print all nodes that are at distance k from a leaf node

#  Binary Tree node
class TreeNode
# Define the accessor and reader of class TreeNode
attr_accessor :data, :left, :right
def initialize(data)
#  Set node value
self.data = data
self.left = nil
self.right = nil
end

end

class BinaryTree
# Define the accessor and reader of class BinaryTree
attr_accessor :root
def initialize()
self.root = nil
end

def findResult(node, result, path, k)
if (node != nil)
if (node.left == nil && node.right == nil)
if (path.length >= k )
result.delete(path[path.length - k])
result.push(path[path.length - k])
end

return
end

path.push(node)
#  Visit left and right subtree using recursively
self.findResult(node.left, result, path, k)
self.findResult(node.right, result, path, k)
#  Remove last node in path
path.delete_at(path.length - 1)
end

end

#   Handles the request of finding kth from left node to root
def distanceKfromLeft(k)
if (k < 0)
return
end

#  This is used to collect unique result
result = []
#  This is used to track the path from root to leaf node
path = []
#  Find nodes
self.findResult(self.root, result, path, k)
print("\n Given K ", k, "\n")
if (result.size() == 0)
#  When result not exists
print(" No result \n")
else

#  Display calculated result
result.each do  | node |
print("  ", node.data)
end

end

end

end

def main()
tree = BinaryTree.new()
#    Binary Tree
#    ------------
#         10
#       /    \
#      -2     5
#     / \    /  \
#    1   3  7    2
#       /    \    \
#      9      8    4
#            /
#           11
tree.root = TreeNode.new(10)
tree.root.left = TreeNode.new(-2)
tree.root.right = TreeNode.new(5)
tree.root.right.right = TreeNode.new(2)
tree.root.right.right.right = TreeNode.new(4)
tree.root.right.left = TreeNode.new(7)
tree.root.right.left.right = TreeNode.new(8)
tree.root.left.left = TreeNode.new(1)
tree.root.left.right = TreeNode.new(3)
tree.root.left.right.left = TreeNode.new(9)
tree.root.right.left.right.left = TreeNode.new(11)
#  Test A
#  K = 2
tree.distanceKfromLeft(2)
#  Test B
#  K = 4
tree.distanceKfromLeft(4)
#  Test C
#  K = 1
tree.distanceKfromLeft(1)
#  Test D
#  K = 3
tree.distanceKfromLeft(3)
end

main()``````

#### Output

`````` Given K 2
10  -2  7  5
Given K 4
10
Given K 1
-2  3  8  2
Given K 3
5  10``````
``````import scala.collection.mutable._;
/*
Scala Program
Print all nodes that are at distance k from a leaf node
*/
// Binary Tree node
class TreeNode(var data: Int,
var left: TreeNode,
var right: TreeNode)
{
def this(data: Int)
{
// Set node value
this(data, null, null)
}
}
class BinaryTree(var root: TreeNode)
{
def this()
{

this(null)
}
def findResult(
node: TreeNode,
result: Set[TreeNode],
path: ArrayBuffer[TreeNode],
k: Int): Unit = {
if (node != null)
{
if (node.left == null && node.right == null)
{
if (path.size >= k)
{
}
return;
}
path += node;
//  Visit left and right subtree using recursively
findResult(node.left, result, path, k);
findResult(node.right, result, path, k);
// Remove last node in path
path.remove(path.size - 1);
}
}
//  Handles the request of finding kth from left node to root
def distanceKfromLeft(k: Int): Unit = {
if (k < 0)
{
return;
}
// This is used to collect unique result
var result: Set[TreeNode] =  Set();
// This is used to track the path from root to leaf node
var path: ArrayBuffer[TreeNode] =
new ArrayBuffer[TreeNode]();
// Find nodes
findResult(this.root, result, path, k);
println("\n Given K " + k);
if (result.size == 0)
{
// When result not exists
print(" No result \n");
}
else
{
// Display calculated result
for ((node) <- result)
{
print("  " + node.data);
}
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var tree: BinaryTree = new BinaryTree();
/*
Binary Tree
------------
10
/    \
-2     5
/ \    /  \
1   3  7    2
/    \    \
9      8    4
/
11
*/
tree.root = new TreeNode(10);
tree.root.left = new TreeNode(-2);
tree.root.right = new TreeNode(5);
tree.root.right.right = new TreeNode(2);
tree.root.right.right.right = new TreeNode(4);
tree.root.right.left = new TreeNode(7);
tree.root.right.left.right = new TreeNode(8);
tree.root.left.left = new TreeNode(1);
tree.root.left.right = new TreeNode(3);
tree.root.left.right.left = new TreeNode(9);
tree.root.right.left.right.left = new TreeNode(11);
// Test A
// K = 2
tree.distanceKfromLeft(2);
// Test B
// K = 4
tree.distanceKfromLeft(4);
// Test C
// K = 1
tree.distanceKfromLeft(1);
// Test D
// K = 3
tree.distanceKfromLeft(3);
}
}``````

#### Output

`````` Given K 2
7  10  -2  5
Given K 4
10
Given K 1
3  -2  2  8
Given K 3
10  5``````
``````/*
Kotlin Program
Print all nodes that are at distance k from a leaf node
*/
// Binary Tree node
class TreeNode
{
var data: Int;
var left: TreeNode ? ;
var right: TreeNode ? ;
constructor(data: Int)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
class BinaryTree
{
var root: TreeNode ? ;
constructor()
{
this.root = null;
}
fun findResult(node: TreeNode ? ,
result : MutableSet< TreeNode >  ,
path : MutableList < TreeNode >  , k : Int): Unit
{
if (node != null)
{
if (node.left == null && node.right == null)
{
if (path.size >= k)
{
}
return;
}
//  Visit left and right subtree using recursively
this.findResult(node.left, result, path, k);
this.findResult(node.right, result, path, k);
// Remove last node in path
path.removeAt(path.size - 1);
}
}
//  Handles the request of finding kth from left node to root
fun distanceKfromLeft(k: Int): Unit
{
if (k < 0)
{
return;
}
// This is used to collect unique result
val result: MutableSet< TreeNode > = mutableSetOf< TreeNode > ();
// This is used to track the path from root to leaf node
val path: MutableList < TreeNode > = mutableListOf < TreeNode > ();
// Find nodes
this.findResult(this.root, result, path, k);
println("\n Given K " + k);
if (result.count() == 0)
{
// When result not exists
print(" No result \n");
}
else
{
// Display calculated result
for (node in result)
{
print("  " + node.data);
}
}
}
}
fun main(args: Array < String > ): Unit
{
val tree: BinaryTree = BinaryTree();
/*
Binary Tree
------------
10
/    \
-2     5
/ \    /  \
1   3  7    2
/    \    \
9      8    4
/
11
*/
tree.root = TreeNode(10);
tree.root?.left = TreeNode(-2);
tree.root?.right = TreeNode(5);
tree.root?.right?.right = TreeNode(2);
tree.root?.right?.right?.right = TreeNode(4);
tree.root?.right?.left = TreeNode(7);
tree.root?.right?.left?.right = TreeNode(8);
tree.root?.left?.left = TreeNode(1);
tree.root?.left?.right = TreeNode(3);
tree.root?.left?.right?.left = TreeNode(9);
tree.root?.right?.left?.right?.left = TreeNode(11);
// Test A
// K = 2
tree.distanceKfromLeft(2);
// Test B
// K = 4
tree.distanceKfromLeft(4);
// Test C
// K = 1
tree.distanceKfromLeft(1);
// Test D
// K = 3
tree.distanceKfromLeft(3);
}``````

#### Output

`````` Given K 2
10  -2  7  5
Given K 4
10
Given K 1
-2  3  8  2
Given K 3
10  5``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

Categories
Relative Post