# Find K smallest leaf nodes from a given Binary Tree

• Difficulty Level : Easy
• Last Updated : 21 Jun, 2021

Given a binary tree and an integer K, the task is to find the K smallest leaf nodes from the given binary tree. The number of leaf nodes will always be at least K.

Examples:

Input:

/  \
2     3
/ \    / \
4  5  6   7
/     \         \
21     8       19
Output: 6 8 19
Explanation:
There are 4 leaf nodes in the above binary tree
out of which 6, 8, 19 are the smallest three leaf nodes.

Input:
11
/  \
12    3
/  \    / \
41 15 61  1
\
8
Output: 1 8 15
Explanation:
There are 4 leaf nodes in the above binary tree
out of which 1, 8, 15 are the smallest three leaf nodes.

Approach: Follow the steps below to solve the problem:

• Traverse the Binary Tree.
• Check for each node if it contains neither left child nor the right child. If found to be true, then that node is a leaf node. Store all such nodes in an array.
• Sort the array of leaf nodes and print the K smallest leaf values from the array.

Below is the implementation of the above approach:

## C++

 `// C++ program of the``// above approach` `#include ``using` `namespace` `std;` `// Structure of``// binary tree node``struct` `Node {``    ``int` `data;``    ``Node *left, *right;``};` `// Function to create new node``Node* newNode(``int` `data)``{``    ``Node* temp = ``new` `Node();``    ``temp->data = data;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// Utility function which calculates``// smallest three nodes of all leaf nodes``void` `storeLeaf(Node* root, vector<``int``>& arr)``{``    ``if` `(!root)``        ``return``;` `    ``// Check if current root is a leaf node``    ``if` `(!root->left and !root->right) {``        ``arr.push_back(root->data);``        ``return``;``    ``}` `    ``// Traverse the left``    ``// and right subtree``    ``storeLeaf(root->left, arr);``    ``storeLeaf(root->right, arr);``}` `// Function to find the K smallest``// nodes of the Binary Tree``void` `KSmallest(Node* root, ``int` `k)``{``    ``vector<``int``> arr;``    ``storeLeaf(root, arr);` `    ``// Sorting the Leaf nodes array``    ``sort(arr.begin(), arr.end());` `    ``// Loop to print the K smallest``    ``// Leaf nodes of the array``    ``for` `(``int` `i = 0; i < k; i++) {``        ``if` `(i < arr.size()) {``            ``cout << arr[i] << ``" "``;``        ``}``        ``else` `{``            ``break``;``        ``}``    ``}``}` `// Driver Code``int` `main()``{``    ``// Construct binary tree``    ``Node* root = newNode(1);``    ``root->left = newNode(2);``    ``root->left->left = newNode(4);``    ``root->left->left->left = newNode(21);``    ``root->left->right = newNode(5);``    ``root->left->right->right = newNode(8);``    ``root->right = newNode(3);``    ``root->right->left = newNode(6);``    ``root->right->right = newNode(7);``    ``root->right->right->right = newNode(19);` `    ``// Function Call``    ``KSmallest(root, 3);``    ``return` `0;``}`

## Java

 `// Java program of the``// above approach``import` `java.util.*;` `class` `GFG{` `// Structure of``// binary tree node``static` `class` `Node``{``    ``int` `data;``    ``Node left, right;``};` `// Function to create new node``static` `Node newNode(``int` `data)``{``    ``Node temp = ``new` `Node();``    ``temp.data = data;``    ``temp.left = temp.right = ``null``;``    ``return` `temp;``}` `// Utility function which calculates``// smallest three nodes of all leaf nodes``static` `Vector storeLeaf(Node root,``                       ``Vector arr)``{``    ``if` `(root == ``null``)``        ``return` `arr;` `    ``// Check if current root is a leaf node``    ``if` `(root.left == ``null` `&&``       ``root.right == ``null``)``    ``{``        ``arr.add(root.data);``        ``return` `arr;``    ``}` `    ``// Traverse the left``    ``// and right subtree``    ``arr = storeLeaf(root.left, arr);``    ``arr = storeLeaf(root.right, arr);``    ``return` `arr;``}` `// Function to find the K smallest``// nodes of the Binary Tree``static` `void` `KSmallest(Node root, ``int` `k)``{``    ``Vector arr = ``new` `Vector();``    ``arr = storeLeaf(root, arr);` `    ``// Sorting the Leaf nodes array``    ``Collections.sort(arr);` `    ``// Loop to print the K smallest``    ``// Leaf nodes of the array``    ``for``(``int` `i = ``0``; i < k; i++)``    ``{``        ``if` `(i < arr.size())``        ``{``            ``System.out.print(arr.get(i) + ``" "``);``        ``}``        ``else``        ``{``            ``break``;``        ``}``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Construct binary tree``    ``Node root = newNode(``1``);``    ``root.left = newNode(``2``);``    ``root.left.left = newNode(``4``);``    ``root.left.left.left = newNode(``21``);``    ``root.left.right = newNode(``5``);``    ``root.left.right.right = newNode(``8``);``    ``root.right = newNode(``3``);``    ``root.right.left = newNode(``6``);``    ``root.right.right = newNode(``7``);``    ``root.right.right.right = newNode(``19``);` `    ``// Function call``    ``KSmallest(root, ``3``);``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program for the``# above approach` `# Binary tree node``class` `Node:``    ``def` `__init__(``self``, data):``      ` `        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Utility function which calculates``# smallest three nodes of all leaf nodes``def` `storeLeaf(root: Node,``              ``arr : ``list``) ``-``> ``None``:` `    ``if` `(``not` `root):``        ``return` `    ``# Check if current root``    ``# is a leaf node``    ``if` `(``not` `root.left ``and``        ``not` `root.right):``        ``arr.append(root.data)``        ``return` `    ``# Traverse the left``    ``# and right subtree``    ``storeLeaf(root.left, arr)``    ``storeLeaf(root.right, arr)` `# Function to find the K smallest``# nodes of the Binary Tree``def` `KSmallest(root: Node,``              ``k: ``int``) ``-``> ``None``:` `    ``arr ``=` `[]``    ``storeLeaf(root, arr)` `    ``# Sorting the Leaf``    ``# nodes array``    ``arr.sort()` `    ``# Loop to print the K smallest``    ``# Leaf nodes of the array``    ``for` `i ``in` `range``(k):``        ``if` `(i < ``len``(arr)):``            ``print``(arr[i], end ``=` `" "``)``        ``else``:``            ``break` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Construct binary tree``    ``root ``=` `Node(``1``)``    ``root.left ``=` `Node(``2``)``    ``root.left.left ``=` `Node(``4``)``    ``root.left.left.left ``=` `Node(``21``)``    ``root.left.right ``=` `Node(``5``)``    ``root.left.right.right ``=` `Node(``8``)``    ``root.right ``=` `Node(``3``)``    ``root.right.left ``=` `Node(``6``)``    ``root.right.right ``=` `Node(``7``)``    ``root.right.right.right ``=` `Node(``19``)` `    ``# Function Call``    ``KSmallest(root, ``3``)` `# This code is contributed by sanjeev2552`

## C#

 `// C# program of the``// above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Structure of``// binary tree node``class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;``};` `// Function to create new node``static` `Node newNode(``int` `data)``{``    ``Node temp = ``new` `Node();``    ``temp.data = data;``    ``temp.left = temp.right = ``null``;``    ``return` `temp;``}` `// Utility function which calculates``// smallest three nodes of all leaf nodes``static` `List<``int``> storeLeaf(Node root,``                           ``List<``int``> arr)``{``    ``if` `(root == ``null``)``        ``return` `arr;` `    ``// Check if current root is a leaf node``    ``if` `(root.left == ``null` `&&``       ``root.right == ``null``)``    ``{``        ``arr.Add(root.data);``        ``return` `arr;``    ``}` `    ``// Traverse the left``    ``// and right subtree``    ``arr = storeLeaf(root.left, arr);``    ``arr = storeLeaf(root.right, arr);``    ``return` `arr;``}` `// Function to find the K smallest``// nodes of the Binary Tree``static` `void` `KSmallest(Node root, ``int` `k)``{``    ``List<``int``> arr = ``new` `List<``int``>();``    ``arr = storeLeaf(root, arr);` `    ``// Sorting the Leaf nodes array``    ``arr.Sort();` `    ``// Loop to print the K smallest``    ``// Leaf nodes of the array``    ``for``(``int` `i = 0; i < k; i++)``    ``{``        ``if` `(i < arr.Count)``        ``{``            ``Console.Write(arr[i] + ``" "``);``        ``}``        ``else``        ``{``            ``break``;``        ``}``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Construct binary tree``    ``Node root = newNode(1);``    ``root.left = newNode(2);``    ``root.left.left = newNode(4);``    ``root.left.left.left = newNode(21);``    ``root.left.right = newNode(5);``    ``root.left.right.right = newNode(8);``    ``root.right = newNode(3);``    ``root.right.left = newNode(6);``    ``root.right.right = newNode(7);``    ``root.right.right.right = newNode(19);` `    ``// Function call``    ``KSmallest(root, 3);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

`6 8 19`

Time Complexity:  O(N + L*logL), Here L is the count of leaf nodes and N is the number of nodes.
Auxiliary Space: O(L + logN)

My Personal Notes arrow_drop_up