# Find K smallest leaf nodes from a given Binary Tree

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`

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)

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

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.