# Find K smallest leaf nodes in a given Binary Tree

Here given code implementation process.

``````/*
Java program
Find K smallest leaf nodes in a given Binary Tree
*/

import java.util.ArrayList;
import java.util.Collections;

// 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()
{
this.root = null;
}
//Display Inorder view of binary tree
public void inorder(TreeNode node)
{
if (node != null)
{
inorder(node.left);
// Print node value
System.out.print("  " + node.data);
inorder(node.right);
}
}

public void getLeafNodes(TreeNode node, ArrayList<Integer> result )
{
if (node != null)
{   if(node.left == null && node.right == null)
{
// Collecting a leaf node value
}
// Recursively visit left and right subtree
getLeafNodes(node.left,result);
getLeafNodes(node.right,result);
}
}

public void smallestKLeaf(int k)
{
if(k < 0)
{
return;
}
if(this.root == null)
{
// When tree is empty
System.out.print("\n Empty Tree \n");

}
// This is used to collecting all leaf nodes
ArrayList<Integer> result = new ArrayList<Integer>();

// Display all tree nodes
System.out.print("\n  All Tree Nodes \n");
this.inorder(this.root);

// Get leaf node

getLeafNodes(this.root , result);
System.out.print("\n ("+k+") Smallest leaf is ");
if(result.size() <= k)
{
// When all element is part of result
for (int i = 0; i < k && i < result.size() ; ++i )
{
System.out.print("  "+result.get(i));
}
}
else
{
// Need to sort element
Collections.sort(result);

for (int i = 0; i < k && i < result.size() ; ++i )
{
System.out.print("  "+result.get(i));
}
}
}

public static void main(String[] args)
{
BinaryTree tree = new BinaryTree();
/*
1
/ \
/   \
/     \
/       \
11        8
/  \     /   \
3   10   6     4
/    / \   /  \
7    5   9 15   2
-----------------------
Binary Tree
-----------------------
*/
tree.root = new TreeNode(1);
tree.root.left = new TreeNode(11);
tree.root.right = new TreeNode(8);
tree.root.left.left = new TreeNode(3);
tree.root.left.right = new TreeNode(10);
tree.root.left.right.left = new TreeNode(7);
tree.root.right.left = new TreeNode(6);
tree.root.right.left.right = new TreeNode(9);
tree.root.right.right = new TreeNode(4);
tree.root.right.left.left = new TreeNode(5);
tree.root.right.right.right = new TreeNode(2);
tree.root.right.right.left = new TreeNode(15);

tree.smallestKLeaf(3);
}
}``````

#### Output

``````  All Tree Nodes
3  11  7  10  1  5  6  9  8  15  4  2
(3) Smallest leaf is   2  3  5``````
``````// Include header file
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
/*
C++ program
Find K smallest leaf nodes in a given Binary Tree
*/

// 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;
}
//Display Inorder view of binary tree
void inorder(TreeNode *node)
{
if (node != NULL)
{
this->inorder(node->left);
// Print node value
cout << "  " << node->data;
this->inorder(node->right);
}
}
void getLeafNodes(TreeNode *node, vector <int> &result)
{
if (node != NULL)
{
if (node->left == NULL && node->right == NULL)
{
result.push_back(node->data);
}
// Recursively visit left and right subtree
this->getLeafNodes(node->left, result);
this->getLeafNodes(node->right, result);
}
}
void smallestKLeaf(int k)
{
if (k < 0)
{
return;
}
if (this->root == NULL)
{
// When tree is empty
cout << "\n Empty Tree \n";
}
// This is used to collecting all leaf nodes
vector < int > result;
// Display all tree nodes
cout << "\n  All Tree Nodes \n";
this->inorder(this->root);
// Get leaf node
this->getLeafNodes(this->root, result);
cout << "\n (" << k << ") Smallest leaf is ";
if (result.size() <= k)
{
// When all element is part of result
for (int i = 0; i < k && i < result.size(); ++i)
{
cout << "  " << result.at(i);
}
}
else
{
// Need to sort element
sort(result.begin(), result.end());
for (int i = 0; i < k && i < result.size(); ++i)
{
cout << "  " << result.at(i);
}
}
}
};
int main()
{
BinaryTree tree = BinaryTree();
/*
1
/ \
/   \
/     \
/       \
11        8
/  \     /   \
3   10   6     4
/    / \   /  \
7    5   9 15   2
-----------------------
Binary Tree
-----------------------
*/
tree.root = new TreeNode(1);
tree.root->left = new TreeNode(11);
tree.root->right = new TreeNode(8);
tree.root->left->left = new TreeNode(3);
tree.root->left->right = new TreeNode(10);
tree.root->left->right->left = new TreeNode(7);
tree.root->right->left = new TreeNode(6);
tree.root->right->left->right = new TreeNode(9);
tree.root->right->right = new TreeNode(4);
tree.root->right->left->left = new TreeNode(5);
tree.root->right->right->right = new TreeNode(2);
tree.root->right->right->left = new TreeNode(15);
tree.smallestKLeaf(3);
return 0;
}``````

#### Output

``````  All Tree Nodes
3  11  7  10  1  5  6  9  8  15  4  2
(3) Smallest leaf is   2  3  5``````
``````
/*
C# program
Find K smallest leaf nodes in a given Binary Tree
*/

// Include namespace system
using System;
using System.Collections.Generic;
// 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()
{
this.root = null;
}
//Display Inorder view of binary tree
public void inorder(TreeNode node)
{
if (node != null)
{
inorder(node.left);
// Print node value
Console.Write("  " + node.data);
inorder(node.right);
}
}
public void getLeafNodes(TreeNode node, List < int > result)
{
if (node != null)
{
if (node.left == null && node.right == null)
{
}
// Recursively visit left and right subtree
getLeafNodes(node.left, result);
getLeafNodes(node.right, result);
}
}
public void smallestKLeaf(int k)
{
if (k < 0)
{
return;
}
if (this.root == null)
{
// When tree is empty
Console.Write("\n Empty Tree \n");
}
// This is used to collecting all leaf nodes
List < int > result = new List <int> ();
// Display all tree nodes
Console.Write("\n  All Tree Nodes \n");
this.inorder(this.root);
// Get leaf node
getLeafNodes(this.root, result);
Console.Write("\n (" + k + ") Smallest leaf is ");
if (result.Count <= k)
{
// When all element is part of result
for (int i = 0; i < k && i < result.Count; ++i)
{
Console.Write("  " + result[i]);
}
}
else
{
// Need to sort element
result.Sort();
for (int i = 0; i < k && i < result.Count; ++i)
{
Console.Write("  " + result[i]);
}
}
}
public static void Main(String[] args)
{
BinaryTree tree = new BinaryTree();
/*
1
/ \
/   \
/     \
/       \
11        8
/  \     /   \
3   10   6     4
/    / \   /  \
7    5   9 15   2
-----------------------
Binary Tree
-----------------------
*/
tree.root = new TreeNode(1);
tree.root.left = new TreeNode(11);
tree.root.right = new TreeNode(8);
tree.root.left.left = new TreeNode(3);
tree.root.left.right = new TreeNode(10);
tree.root.left.right.left = new TreeNode(7);
tree.root.right.left = new TreeNode(6);
tree.root.right.left.right = new TreeNode(9);
tree.root.right.right = new TreeNode(4);
tree.root.right.left.left = new TreeNode(5);
tree.root.right.right.right = new TreeNode(2);
tree.root.right.right.left = new TreeNode(15);
tree.smallestKLeaf(3);
}
}``````

#### Output

``````  All Tree Nodes
3  11  7  10  1  5  6  9  8  15  4  2
(3) Smallest leaf is   2  3  5``````
``````<?php
/*
Php program
Find K smallest leaf nodes in a given Binary Tree
*/

// Binary Tree node
class TreeNode
{
public \$data;
public \$left;
public \$right;

function __construct(\$data)
{
// Set node value
\$this->data = \$data;
\$this->left = null;
\$this->right = null;
}
}
class BinaryTree
{
public \$root;

function __construct()
{
\$this->root = null;
}
//Display Inorder view of binary tree
public	function inorder(\$node)
{
if (\$node != null)
{
\$this->inorder(\$node->left);
// Print node value
echo "  ". \$node->data;
\$this->inorder(\$node->right);
}
}
public	function getLeafNodes(\$node, &\$result)
{
if (\$node != null)
{
if (\$node->left == null && \$node->right == null)
{
// Collecting a leaf node value
\$result[] = \$node->data;
}
// Recursively visit left and right subtree
\$this->getLeafNodes(\$node->left, \$result);
\$this->getLeafNodes(\$node->right, \$result);
}
}
public	function smallestKLeaf(\$k)
{
if (\$k < 0)
{
return;
}
if (\$this->root == null)
{
// When tree is empty
echo "\n Empty Tree \n";
}
// This is used to collecting all leaf nodes
\$result = array();
// Display all tree nodes
echo "\n  All Tree Nodes \n";
\$this->inorder(\$this->root);
// Get leaf node
\$this->getLeafNodes(\$this->root, \$result);
echo "\n (". \$k .") Smallest leaf is ";
if (count(\$result) <= \$k)
{
// When all element is part of result
for (\$i = 0; \$i < \$k && \$i < count(\$result); ++\$i)
{
echo "  ". \$result[\$i];
}
}
else
{
// Need to sort element
sort(\$result);
for (\$i = 0; \$i < \$k && \$i < count(\$result); ++\$i)
{
echo "  ". \$result[\$i];
}
}
}
}

function main()
{
\$tree = new BinaryTree();
/*
1
/ \
/   \
/     \
/       \
11        8
/  \     /   \
3   10   6     4
/    / \   /  \
7    5   9 15   2
-----------------------
Binary Tree
-----------------------
*/
\$tree->root = new TreeNode(1);
\$tree->root->left = new TreeNode(11);
\$tree->root->right = new TreeNode(8);
\$tree->root->left->left = new TreeNode(3);
\$tree->root->left->right = new TreeNode(10);
\$tree->root->left->right->left = new TreeNode(7);
\$tree->root->right->left = new TreeNode(6);
\$tree->root->right->left->right = new TreeNode(9);
\$tree->root->right->right = new TreeNode(4);
\$tree->root->right->left->left = new TreeNode(5);
\$tree->root->right->right->right = new TreeNode(2);
\$tree->root->right->right->left = new TreeNode(15);
\$tree->smallestKLeaf(3);
}
main();``````

#### Output

``````  All Tree Nodes
3  11  7  10  1  5  6  9  8  15  4  2
(3) Smallest leaf is   2  3  5``````
``````// Node js
//  Find K smallest leaf nodes in a given Binary Tree

// 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;
}
//Display Inorder view of binary tree
inorder(node)
{
if (node != null)
{
this.inorder(node.left);
// Print node value
process.stdout.write("  " + node.data);
this.inorder(node.right);
}
}
getLeafNodes(node, result)
{
if (node != null)
{
if (node.left == null && node.right == null)
{
result.push(node.data);
}
// Recursively visit left and right subtree
this.getLeafNodes(node.left, result);
this.getLeafNodes(node.right, result);
}
}
sortByValue (a, b)
{
return a < b;
}

smallestKLeaf(k)
{
if (k < 0)
{
return;
}
if (this.root == null)
{
// When tree is empty
process.stdout.write("\n Empty Tree \n");
}
// This is used to collecting all leaf nodes
var result = [];
// Display all tree nodes
process.stdout.write("\n  All Tree Nodes \n");
this.inorder(this.root);
// Get leaf node
this.getLeafNodes(this.root, result);

process.stdout.write("\n (" + k + ") Smallest leaf is ");
if (result.Count <= k)
{
// When all element is part of result
for (var i = 0; i < k && i < result.Count; ++i)
{
process.stdout.write("  " + result[i]);
}
}
else
{
// Need to sort element
result.sort((a,b)=> a >= b);

for (var i = 0; i < k && i < result.length; ++i)
{
process.stdout.write("  " + result[i]);
}
}
}
}

function main()
{
var tree = new BinaryTree();
/*
1
/ \
/   \
/     \
/       \
11        8
/  \     /   \
3   10   6     4
/    / \   /  \
7    5   9 15   2
-----------------------
Binary Tree
-----------------------
*/
tree.root = new TreeNode(1);
tree.root.left = new TreeNode(11);
tree.root.right = new TreeNode(8);
tree.root.left.left = new TreeNode(3);
tree.root.left.right = new TreeNode(10);
tree.root.left.right.left = new TreeNode(7);
tree.root.right.left = new TreeNode(6);
tree.root.right.left.right = new TreeNode(9);
tree.root.right.right = new TreeNode(4);
tree.root.right.left.left = new TreeNode(5);
tree.root.right.right.right = new TreeNode(2);
tree.root.right.right.left = new TreeNode(15);
tree.smallestKLeaf(3);
}
main();``````

#### Output

``````  All Tree Nodes
3  11  7  10  1  5  6  9  8  15  4  2
(3) Smallest leaf is   2  3  5``````
``````#   Python 3 program
#   Find K smallest leaf nodes in a given Binary Tree

#  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

# Display Inorder view of binary tree
def inorder(self, node) :
if (node != None) :
self.inorder(node.left)
#  Print node value
print("  ", node.data, end = "")
self.inorder(node.right)

def getLeafNodes(self, node, result) :
if (node != None) :
if (node.left == None and node.right == None) :
# get a leaf node
result.append(node.data)

#  Recursively visit left and right subtree
self.getLeafNodes(node.left, result)
self.getLeafNodes(node.right, result)

def smallestKLeaf(self, k) :
if (k < 0) :
return

if (self.root == None) :
#  When tree is empty
print("\n Empty Tree ")

#  This is used to collecting all leaf nodes
result = []
#  Display all tree nodes
print("\n  All Tree Nodes ")
self.inorder(self.root)
#  Get leaf node
self.getLeafNodes(self.root, result)
print("\n (", k ,") Smallest leaf is ", end = "")
if (len(result) <= k) :
#  When all element is part of result
i = 0
while (i < k and i < len(result)) :
print("  ", result[i], end = "")
i += 1

else :
#  Need to sort element
result.sort()
i = 0
while (i < k and i < len(result)) :
print("  ", result[i], end = "")
i += 1

def main() :
tree = BinaryTree()
#
#                   1
#                  / \
#                 /   \
#                /     \
#               /       \
#              11        8
#             /  \     /   \
#            3   10   6     4
#               /    / \   /  \
#              7    5   9 15   2
#        -----------------------
#           Binary Tree
#        -----------------------

tree.root = TreeNode(1)
tree.root.left = TreeNode(11)
tree.root.right = TreeNode(8)
tree.root.left.left = TreeNode(3)
tree.root.left.right = TreeNode(10)
tree.root.left.right.left = TreeNode(7)
tree.root.right.left = TreeNode(6)
tree.root.right.left.right = TreeNode(9)
tree.root.right.right = TreeNode(4)
tree.root.right.left.left = TreeNode(5)
tree.root.right.right.right = TreeNode(2)
tree.root.right.right.left = TreeNode(15)
tree.smallestKLeaf(3)

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

#### Output

``````  All Tree Nodes
3   11   7   10   1   5   6   9   8   15   4   2
( 3 ) Smallest leaf is    2   3   5``````
``````#   Ruby program
#   Find K smallest leaf nodes in a given Binary Tree

#  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

# Display Inorder view of binary tree
def inorder(node)
if (node != nil)
self.inorder(node.left)
#  Print node value
print("  ", node.data)
self.inorder(node.right)
end

end

def getLeafNodes(node, result)
if (node != nil)
if (node.left == nil && node.right == nil)
result.push(node.data)
end

#  Recursively visit left and right subtree
self.getLeafNodes(node.left, result)
self.getLeafNodes(node.right, result)
end

end

def smallestKLeaf(k)
if (k < 0)
return
end

if (self.root == nil)
#  When tree is empty
print("\n Empty Tree \n")
end

#  This is used to collecting all leaf nodes
result = []
#  Display all tree nodes
print("\n  All Tree Nodes \n")
self.inorder(self.root)
#  Get leaf node
self.getLeafNodes(self.root, result)
print("\n (", k ,") Smallest leaf is ")
if (result.length <= k)
#  When all element is part of result
i = 0
while (i < k && i < result.length)
print("  ", result[i])
i += 1
end

else
#  Need to sort element
result = result.sort
i = 0
while (i < k && i < result.length)
print("  ", result[i])
i += 1
end

end

end

end

def main()
tree = BinaryTree.new()
#
#                   1
#                  / \
#                 /   \
#                /     \
#               /       \
#              11        8
#             /  \     /   \
#            3   10   6     4
#               /    / \   /  \
#              7    5   9 15   2
#        -----------------------
#           Binary Tree
#        -----------------------

tree.root = TreeNode.new(1)
tree.root.left = TreeNode.new(11)
tree.root.right = TreeNode.new(8)
tree.root.left.left = TreeNode.new(3)
tree.root.left.right = TreeNode.new(10)
tree.root.left.right.left = TreeNode.new(7)
tree.root.right.left = TreeNode.new(6)
tree.root.right.left.right = TreeNode.new(9)
tree.root.right.right = TreeNode.new(4)
tree.root.right.left.left = TreeNode.new(5)
tree.root.right.right.right = TreeNode.new(2)
tree.root.right.right.left = TreeNode.new(15)
tree.smallestKLeaf(3)
end

main()``````

#### Output

``````  All Tree Nodes
3  11  7  10  1  5  6  9  8  15  4  2
(3) Smallest leaf is   2  3  5``````
``````/*
Kotlin program
Find K smallest leaf nodes in a given Binary Tree
*/
// 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;
}
//Display Inorder view of binary tree
fun inorder(node: TreeNode ? ): Unit
{
if (node != null)
{
this.inorder(node.left);
// Print node value
print("  " + node.data);
this.inorder(node.right);
}
}
fun getLeafNodes(node: TreeNode ? , result: MutableList <Int> ): Unit
{
if (node != null)
{
if (node.left == null && node.right == null)
{
}
// Recursively visit left and right subtree
this.getLeafNodes(node.left, result);
this.getLeafNodes(node.right, result);
}
}
fun smallestKLeaf(k: Int): Unit
{
if (k < 0)
{
return;
}
if (this.root == null)
{
// When tree is empty
print("\n Empty Tree \n");
}
// This is used to collecting all leaf nodes
var result: MutableList < Int > = mutableListOf < Int > ();
// Display all tree nodes
print("\n  All Tree Nodes \n");
this.inorder(this.root);
// Get leaf node
this.getLeafNodes(this.root, result);
print("\n (" + k + ") Smallest leaf is ");
if (result.size <= k)
{
// When all element is part of result
var i: Int = 0;
while (i < k && i < result.size)
{
print("  " + result[i]);
i += 1;
}
}
else
{
// Need to sort element
result.sort();
var i: Int = 0;
while (i < k && i < result.size)
{
print("  " + result[i]);
i += 1;
}
}
}
}
fun main(args: Array < String > ): Unit
{
var tree: BinaryTree = BinaryTree();
/*
1
/ \
/   \
/     \
/       \
11        8
/  \     /   \
3   10   6     4
/    / \   /  \
7    5   9 15   2
-----------------------
Binary Tree
-----------------------

*/
tree.root = TreeNode(1);
tree.root?.left = TreeNode(11);
tree.root?.right = TreeNode(8);
tree.root?.left?.left = TreeNode(3);
tree.root?.left?.right = TreeNode(10);
tree.root?.left?.right?.left = TreeNode(7);
tree.root?.right?.left = TreeNode(6);
tree.root?.right?.left?.right = TreeNode(9);
tree.root?.right?.right = TreeNode(4);
tree.root?.right?.left?.left = TreeNode(5);
tree.root?.right?.right?.right = TreeNode(2);
tree.root?.right?.right?.left = TreeNode(15);
tree.smallestKLeaf(3);
}``````

#### Output

``````  All Tree Nodes
3  11  7  10  1  5  6  9  8  15  4  2
(3) Smallest leaf is   2  3  5``````
``````/*
Swift 4 program
Find K smallest leaf nodes in a given Binary Tree
*/
// Binary Tree node
class TreeNode
{
var data: Int;
var left: TreeNode? ;
var right: TreeNode? ;
init(_ data: Int)
{
// Set node value
self.data = data;
self.left = nil;
self.right = nil;
}
}
class BinaryTree
{
var root: TreeNode? ;
init()
{
self.root = nil;
}
//Display Inorder view of binary tree
func inorder(_ node: TreeNode? )
{
if (node  != nil)
{
self.inorder(node!.left);
// Print node value
print("  ", node!.data, terminator: "");
self.inorder(node!.right);
}
}
func getLeafNodes(_ node: TreeNode? , _ result : inout [Int])
{
if (node  != nil)
{
if (node!.left == nil && node!.right == nil)
{
result.append(node!.data);
}
// Recursively visit left and right subtree
self.getLeafNodes(node!.left, &result);
self.getLeafNodes(node!.right, &result);
}
}
func smallestKLeaf(_ k: Int)
{
if (k < 0)
{
return;
}
if (self.root == nil)
{
// When tree is empty
print("\n Empty Tree ");
}
// This is used to collecting all leaf nodes

var result = [Int]();
// Display all tree nodes
print("\n  All Tree Nodes ");
self.inorder(self.root);
// Get leaf node
self.getLeafNodes(self.root, &result);
print("\n (", k ,") Smallest leaf is ", terminator: "");
if (result.count <= k)
{
// When all element is part of result
var i: Int = 0;
while (i < k && i < result.count)
{
print("  ", result[i], terminator: "");
i += 1;
}
}
else
{
// Need to sort element
result.sort();
var i: Int = 0;
while (i < k && i < result.count)
{
print("  ", result[i], terminator: "");
i += 1;
}
}
}
}
func main()
{
let tree: BinaryTree = BinaryTree();
/*
1
/ \
/   \
/     \
/       \
11        8
/  \     /   \
3   10   6     4
/    / \   /  \
7    5   9 15   2
-----------------------
Binary Tree
-----------------------

*/
tree.root = TreeNode(1);
tree.root!.left = TreeNode(11);
tree.root!.right = TreeNode(8);
tree.root!.left!.left = TreeNode(3);
tree.root!.left!.right = TreeNode(10);
tree.root!.left!.right!.left = TreeNode(7);
tree.root!.right!.left = TreeNode(6);
tree.root!.right!.left!.right = TreeNode(9);
tree.root!.right!.right = TreeNode(4);
tree.root!.right!.left!.left = TreeNode(5);
tree.root!.right!.right!.right = TreeNode(2);
tree.root!.right!.right!.left = TreeNode(15);
tree.smallestKLeaf(3);
}
main();``````

#### Output

``````  All Tree Nodes
3   11   7   10   1   5   6   9   8   15   4   2
( 3 ) Smallest leaf is    2   3   5``````
``````import scala.collection.mutable._ ;
/*
Scala program
Find K smallest leaf nodes in a given Binary Tree
*/
// Binary Tree node
class TreeNode(var data: Int , var left: TreeNode , var right: TreeNode)
{
def this(data: Int)
{
this(data, null, null);
}
}
class BinaryTree(var root: TreeNode)
{
def this()
{
this(null);
}
//Display Inorder view of binary tree
def inorder(node: TreeNode): Unit = {
if (node != null)
{
this.inorder(node.left);
// Print node value
print("  " + node.data);
this.inorder(node.right);
}
}
def getLeafNodes(node: TreeNode, result: ArrayBuffer[Int] ): Unit = {
if (node != null)
{
if (node.left == null && node.right == null)
{
result += node.data;
}
// Recursively visit left and right subtree
this.getLeafNodes(node.left, result);
this.getLeafNodes(node.right, result);
}
}
def smallestKLeaf(k: Int): Unit = {
if (k < 0)
{
return;
}
if (this.root == null)
{
// When tree is empty
print("\n Empty Tree \n");
}
// This is used to collecting all leaf nodes
var result = ArrayBuffer[Int]();
// Display all tree nodes
print("\n  All Tree Nodes \n");
this.inorder(this.root);
// Get leaf node
this.getLeafNodes(this.root, result);
print("\n (" + k + ") Smallest leaf is ");
if (result.size <= k)
{
// When all element is part of result
var i: Int = 0;
while (i < k && i < result.size)
{
print("  " + result(i));
i += 1;
}
}
else
{
// Need to sort element
result = result.sorted;
var i = 0;
while (i < k && i < result.size)
{
print("  " + result(i));
i += 1;
}
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var tree: BinaryTree = new BinaryTree();
/*
1
/ \
/   \
/     \
/       \
11        8
/  \     /   \
3   10   6     4
/    / \   /  \
7    5   9 15   2
-----------------------
Binary Tree
-----------------------

*/
tree.root = new TreeNode(1);
tree.root.left = new TreeNode(11);
tree.root.right = new TreeNode(8);
tree.root.left.left = new TreeNode(3);
tree.root.left.right = new TreeNode(10);
tree.root.left.right.left = new TreeNode(7);
tree.root.right.left = new TreeNode(6);
tree.root.right.left.right = new TreeNode(9);
tree.root.right.right = new TreeNode(4);
tree.root.right.left.left = new TreeNode(5);
tree.root.right.right.right = new TreeNode(2);
tree.root.right.right.left = new TreeNode(15);
tree.smallestKLeaf(3);
}
}``````

#### Output

``````  All Tree Nodes
3  11  7  10  1  5  6  9  8  15  4  2
(3) Smallest leaf is   2  3  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.