Open in App
Not now

# Largest number in BST which is less than or equal to N

• Difficulty Level : Easy
• Last Updated : 15 Feb, 2023

We have a binary search tree and a number N. Our task is to find the greatest number in the binary search tree that is less than or equal to N. Print the value of the element if it exists otherwise print -1.

Examples:

For the above given binary search tree-

```Input : N = 24
Output :result = 21
(searching for 24 will be like-5->12->21)

Input  : N = 4
Output : result = 3
(searching for 4 will be like-5->2->3)```
Recommended Practice

We follow recursive approach for solving this problem. We start searching for element from root node. If we reach a leaf and its value is greater than N, element does not exist so return -1. Else if node’s value is less than or equal to N and right value is NULL or greater than N, then return the node value as it will be the answer.

Otherwise if node’s value is greater than N, then search for the element in the left subtree else search for the element in the right subtree by calling the same function by passing the left or right values accordingly.

Implementation:

## C++

 `// C++ code to find the largest value smaller` `// than or equal to N` `#include ` `using` `namespace` `std;`   `struct` `Node {` `    ``int` `key;` `    ``Node *left, *right;` `};`   `// To create new BST Node` `Node* newNode(``int` `item)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->key = item;` `    ``temp->left = temp->right = NULL;` `    ``return` `temp;` `}`   `// To insert a new node in BST` `Node* insert(Node* node, ``int` `key)` `{` `    ``// if tree is empty return new node` `    ``if` `(node == NULL)` `        ``return` `newNode(key);`   `    ``// if key is less than or greater than` `    ``// node value then recur down the tree` `    ``if` `(key < node->key)` `        ``node->left = insert(node->left, key);` `    ``else` `if` `(key > node->key)` `        ``node->right = insert(node->right, key);`   `    ``// return the (unchanged) node pointer` `    ``return` `node;` `}`   `// function to find max value less than N` `int` `findMaxforN(Node* root, ``int` `N)` `{` `    ``// Base cases` `    ``if` `(root == NULL)` `        ``return` `-1;` `    ``if` `(root->key == N)` `        ``return` `N;`   `    ``// If root's value is smaller, try in right` `    ``// subtree` `    ``else` `if` `(root->key < N) {` `        ``int` `k = findMaxforN(root->right, N);` `        ``if` `(k == -1)` `            ``return` `root->key;` `        ``else` `            ``return` `k;` `    ``}`   `    ``// If root's key is greater, return value` `    ``// from left subtree.` `    ``else` `if` `(root->key > N) ` `        ``return` `findMaxforN(root->left, N);    ` `}`   `// Driver code` `int` `main()` `{` `    ``int` `N = 4;`   `    ``// creating following BST` `    ``/*` `                  ``5` `               ``/   \ ` `             ``2     12` `           ``/  \    /  \ ` `          ``1   3   9   21` `                     ``/   \  ` `                    ``19   25  */` `    ``Node* root = insert(root, 25);` `    ``insert(root, 2);` `    ``insert(root, 1);` `    ``insert(root, 3);` `    ``insert(root, 12);` `    ``insert(root, 9);` `    ``insert(root, 21);` `    ``insert(root, 19);` `    ``insert(root, 25);`   `    ``printf``(``"%d"``, findMaxforN(root, N));`   `    ``return` `0;` `}`

## Java

 `// Java code to find the largest value smaller ` `// than or equal to N ` `class` `GfG { `   `static` `class` `Node { ` `    ``int` `key; ` `    ``Node left, right; ` `}`   `// To create new BST Node ` `static` `Node newNode(``int` `item) ` `{ ` `    ``Node temp = ``new` `Node(); ` `    ``temp.key = item; ` `    ``temp.left = ``null``;` `    ``temp.right = ``null``; ` `    ``return` `temp; ` `} `   `// To insert a new node in BST ` `static` `Node insert(Node node, ``int` `key) ` `{ ` `    ``// if tree is empty return new node ` `    ``if` `(node == ``null``) ` `        ``return` `newNode(key); `   `    ``// if key is less than or greater than ` `    ``// node value then recur down the tree ` `    ``if` `(key < node.key) ` `        ``node.left = insert(node.left, key); ` `    ``else` `if` `(key > node.key) ` `        ``node.right = insert(node.right, key); `   `    ``// return the (unchanged) node pointer ` `    ``return` `node; ` `} `   `// function to find max value less than N ` `static` `int` `findMaxforN(Node root, ``int` `N) ` `{ ` `    ``// Base cases ` `    ``if` `(root == ``null``) ` `        ``return` `-``1``; ` `    ``if` `(root.key == N) ` `        ``return` `N; `   `    ``// If root's value is smaller, try in right ` `    ``// subtree ` `    ``else` `if` `(root.key < N) { ` `        ``int` `k = findMaxforN(root.right, N); ` `        ``if` `(k == -``1``) ` `            ``return` `root.key; ` `        ``else` `            ``return` `k; ` `    ``} `   `    ``// If root's key is greater, return value ` `    ``// from left subtree. ` `    ``else` `if` `(root.key > N) ` `        ``return` `findMaxforN(root.left, N);` `    ``return` `-``1``;` `} `   `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `N = ``4``; `   `    ``// creating following BST ` `    ``/* ` `                ``5 ` `            ``/ \ ` `            ``2     12 ` `        ``/ \ / \ ` `        ``1 3 9 21 ` `                    ``/ \ ` `                    ``19 25 */` `    ``Node root = ``null``;` `    ``root = insert(root, ``25``); ` `    ``insert(root, ``2``); ` `    ``insert(root, ``1``); ` `    ``insert(root, ``3``); ` `    ``insert(root, ``12``); ` `    ``insert(root, ``9``); ` `    ``insert(root, ``21``); ` `    ``insert(root, ``19``); ` `    ``insert(root, ``25``); `   `    ``System.out.println(findMaxforN(root, N)); ` `}` `} `

## Python3

 `# Python3 code to find the largest ` `# value smaller than or equal to N` `class` `newNode: `   `    ``# Constructor to create a new node ` `    ``def` `__init__(``self``, data): ` `        ``self``.key ``=` `data ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# To insert a new node in BST ` `def` `insert(node, key):` `    `  `    ``# if tree is empty return new node ` `    ``if` `node ``=``=` `None``: ` `        ``return` `newNode(key)`   `    ``# if key is less than or greater than ` `    ``# node value then recur down the tree ` `    ``if` `key < node.key: ` `        ``node.left ``=` `insert(node.left, key) ` `    ``elif` `key > node.key: ` `        ``node.right ``=` `insert(node.right, key)` `        `  `    ``# return the (unchanged) node pointer ` `    ``return` `node`   `# function to find max value less than N ` `def` `findMaxforN(root, N):` `    `  `    ``# Base cases ` `    ``if` `root ``=``=` `None``: ` `        ``return` `-``1` `    ``if` `root.key ``=``=` `N: ` `        ``return` `N`   `    ``# If root's value is smaller, try in ` `    ``# right subtree ` `    ``elif` `root.key < N: ` `        ``k ``=` `findMaxforN(root.right, N) ` `        ``if` `k ``=``=` `-``1``:` `            ``return` `root.key ` `        ``else``:` `            ``return` `k`   `    ``# If root's key is greater, return ` `    ``# value from left subtree. ` `    ``elif` `root.key > N: ` `        ``return` `findMaxforN(root.left, N)`   `# Driver code ` `if` `__name__ ``=``=` `'__main__'``:` `    ``N ``=` `4`   `    ``# creating following BST ` `    ``# ` `    ``#             5 ` `    ``#         / \ ` `    ``#         2     12 ` `    ``#     / \ / \ ` `    ``#     1 3 9 21 ` `    ``#                 / \ ` `    ``#             19 25 ` `    ``root ``=` `None` `    ``root ``=` `insert(root, ``25``)` `    ``insert(root, ``2``) ` `    ``insert(root, ``1``) ` `    ``insert(root, ``3``) ` `    ``insert(root, ``12``) ` `    ``insert(root, ``9``) ` `    ``insert(root, ``21``) ` `    ``insert(root, ``19``) ` `    ``insert(root, ``25``) ` `    ``print``(findMaxforN(root, N)) `   `# This code is contributed by PranchalK`

## C#

 `// C# code to find the largest value ` `// smaller than or equal to N ` `using` `System;`   `class` `GFG` `{ `   `    ``class` `Node ` `    ``{ ` `        ``public` `int` `key; ` `        ``public` `Node left, right; ` `    ``} `   `    ``// To create new BST Node ` `    ``static` `Node newNode(``int` `item) ` `    ``{ ` `        ``Node temp = ``new` `Node(); ` `        ``temp.key = item; ` `        ``temp.left = ``null``; ` `        ``temp.right = ``null``; ` `        ``return` `temp; ` `    ``} `   `    ``// To insert a new node in BST ` `    ``static` `Node insert(Node node, ``int` `key) ` `    ``{ ` `        ``// if tree is empty return new node ` `        ``if` `(node == ``null``) ` `            ``return` `newNode(key); `   `        ``// if key is less than or greater than ` `        ``// node value then recur down the tree ` `        ``if` `(key < node.key) ` `            ``node.left = insert(node.left, key); ` `        ``else` `if` `(key > node.key) ` `            ``node.right = insert(node.right, key); `   `        ``// return the (unchanged) node pointer ` `        ``return` `node; ` `    ``} `   `    ``// function to find max value less than N ` `    ``static` `int` `findMaxforN(Node root, ``int` `N) ` `    ``{ ` `        ``// Base cases ` `        ``if` `(root == ``null``) ` `            ``return` `-1; ` `        ``if` `(root.key == N) ` `            ``return` `N; `   `        ``// If root's value is smaller, ` `        ``// try in right subtree ` `        ``else` `if` `(root.key < N) ` `        ``{ ` `            ``int` `k = findMaxforN(root.right, N); ` `            ``if` `(k == -1) ` `                ``return` `root.key; ` `            ``else` `                ``return` `k; ` `        ``} `   `        ``// If root's key is greater, return ` `        ``// value from left subtree. ` `        ``else` `if` `(root.key > N) ` `            ``return` `findMaxforN(root.left, N); ` `        ``return` `-1; ` `    ``} `   `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int` `N = 4; `   `        ``// creating following BST ` `        ``/* ` `                    ``5 ` `                ``/ \ ` `                ``2 12 ` `            ``/ \ / \ ` `            ``1 3 9 21 ` `                        ``/ \ ` `                        ``19 25 */` `        ``Node root = ``null``; ` `        ``root = insert(root, 25); ` `        ``insert(root, 2); ` `        ``insert(root, 1); ` `        ``insert(root, 3); ` `        ``insert(root, 12); ` `        ``insert(root, 9); ` `        ``insert(root, 21); ` `        ``insert(root, 19); ` `        ``insert(root, 25); `   `        ``Console.WriteLine(findMaxforN(root, N)); ` `    ``} ` `} `   `// This code is contributed 29AjayKumar`

## Javascript

 ``

Output

`3`

Time Complexity: O(h), where h is height of BST.
Auxiliary Space: O(h), The extra space is used in recursion call stack.

Iterative Solution: Below is an iterative solution and it does not require extra space for recursion call stack.

Implementation:

## C++

 `// C++ code to find the largest value smaller` `// than or equal to N` `#include ` `using` `namespace` `std;`   `struct` `Node {` `    ``int` `key;` `    ``Node *left, *right;` `};`   `// To create new BST Node` `Node* newNode(``int` `item)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->key = item;` `    ``temp->left = temp->right = NULL;` `    ``return` `temp;` `}`   `// To insert a new node in BST` `Node* insert(Node* node, ``int` `key)` `{` `    ``// if tree is empty return new node` `    ``if` `(node == NULL)` `        ``return` `newNode(key);`   `    ``// if key is less than or greater than` `    ``// node value then recur down the tree` `    ``if` `(key < node->key)` `        ``node->left = insert(node->left, key);` `    ``else` `if` `(key > node->key)` `        ``node->right = insert(node->right, key);`   `    ``// return the (unchanged) node pointer` `    ``return` `node;` `}`   `// function to find max value less than N` `void` `findMaxforN(Node* root, ``int` `N)` `{` `    ``// Start from root and keep looking for larger  ` `    ``while` `(root != NULL && root->right != NULL) {`   `        ``// If root is smaller go to right side` `        ``if` `(N > root->key && N >= root->right->key)` `            ``root = root->right;`   `        ``// If root is greater go to left side ` `        ``else` `if` `(N < root->key)` `            ``root = root->left;`   `        ``else` `            ``break``;` `    ``}` `    ``if` `(root == NULL || root->key > N)` `        ``cout << -1;` `    ``else` `        ``cout << root->key;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `N = 50;` `    ``Node* root = insert(root, 5);` `    ``insert(root, 2);` `    ``insert(root, 1);` `    ``insert(root, 3);` `    ``insert(root, 12);` `    ``insert(root, 9);` `    ``insert(root, 21);` `    ``insert(root, 19);` `    ``insert(root, 25);`   `    ``findMaxforN(root, N);` `    ``return` `0;` `}`

## Java

 `// Java code to find the largest value smaller` `// than or equal to N` `import` `java.util.*;` `class` `GFG{`   `  ``static` `class` `Node {` `    ``int` `key;` `    ``Node left, right;` `  ``};`   `  ``// To create new BST Node` `  ``static` `Node newNode(``int` `item)` `  ``{` `    ``Node temp = ``new` `Node();` `    ``temp.key = item;` `    ``temp.left = temp.right = ``null``;` `    ``return` `temp;` `  ``}`   `  ``// To insert a new node in BST` `  ``static` `Node insert(Node node, ``int` `key)` `  ``{` `    ``// if tree is empty return new node` `    ``if` `(node == ``null``)` `      ``return` `newNode(key);`   `    ``// if key is less than or greater than` `    ``// node value then recur down the tree` `    ``if` `(key < node.key)` `      ``node.left = insert(node.left, key);` `    ``else` `if` `(key > node.key)` `      ``node.right = insert(node.right, key);`   `    ``// return the (unchanged) node pointer` `    ``return` `node;` `  ``}`   `  ``// function to find max value less than N` `  ``static` `void` `findMaxforN(Node root, ``int` `N)` `  ``{` `    ``// Start from root and keep looking for larger  ` `    ``while` `(root != ``null` `&& root.right != ``null``) {`   `      ``// If root is smaller go to right side` `      ``if` `(N > root.key && N >= root.right.key)` `        ``root = root.right;`   `      ``// If root is greater go to left side ` `      ``else` `if` `(N < root.key)` `        ``root = root.left;`   `      ``else` `        ``break``;` `    ``}` `    ``if` `(root == ``null` `|| root.key > N)` `      ``System.out.print(-``1``);` `    ``else` `      ``System.out.print(root.key);` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `N = ``50``;` `    ``Node root = insert(``null``, ``5``);` `    ``insert(root, ``2``);` `    ``insert(root, ``1``);` `    ``insert(root, ``3``);` `    ``insert(root, ``12``);` `    ``insert(root, ``9``);` `    ``insert(root, ``21``);` `    ``insert(root, ``19``);` `    ``insert(root, ``25``);`   `    ``findMaxforN(root, N);` `  ``}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 code to find the largest value` `# smaller than or equal to N`   `class` `newNode:` `    `  `    ``# To create new BST Node` `    ``def` `__init__(``self``, data):` `        `  `        ``self``.key ``=` `data` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# To insert a new node in BST` `def` `insert(node, key):` `    `  `    ``# If tree is empty return new node` `    ``if` `(node ``=``=` `None``):` `        ``return` `newNode(key)`   `    ``# If key is less than or greater than` `    ``# node value then recur down the tree` `    ``if` `(key < node.key):` `        ``node.left ``=` `insert(node.left, key)` `    ``elif` `(key > node.key):` `        ``node.right ``=` `insert(node.right, key)`   `    ``# Return the (unchanged) node pointer` `    ``return` `node`   `# Function to find max value less than N` `def` `findMaxforN(root, N):` `    `  `    ``# Start from root and keep looking for larger  ` `    ``while` `(root !``=` `None` `and` `root.right !``=` `None``):` `        `  `        ``# If root is smaller go to right side` `        ``if` `(N > root.key ``and` `N >``=` `root.right.key):` `            ``root ``=` `root.right`   `        ``# If root is greater go to left side ` `        ``elif` `(N < root.key):` `            ``root ``=` `root.left` `        ``else``:` `            ``break` `        `  `    ``if` `(root ``=``=` `None` `or` `root.key > N):` `        ``print``(``-``1``)` `    ``else``:` `        ``print``(root.key)`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``N ``=` `50` `    `  `    ``root ``=` `None` `    ``root ``=` `insert(root, ``5``)` `    ``insert(root, ``2``)` `    ``insert(root, ``1``)` `    ``insert(root, ``3``)` `    ``insert(root, ``12``)` `    ``insert(root, ``9``)` `    ``insert(root, ``21``)` `    ``insert(root, ``19``)` `    ``insert(root, ``25``)`   `    ``findMaxforN(root, N)`   `# This code is contributed by bgangwar59`

## C#

 `// C# code to find the largest value smaller` `// than or equal to N` `using` `System;`   `public` `class` `GFG {`   `  ``public` `class` `Node {` `    ``public` `int` `key;` `    ``public` `Node left, right;` `  ``};`   `  ``// To create new BST Node` `  ``static` `Node newNode(``int` `item) {` `    ``Node temp = ``new` `Node();` `    ``temp.key = item;` `    ``temp.left = temp.right = ``null``;` `    ``return` `temp;` `  ``}`   `  ``// To insert a new node in BST` `  ``static` `Node insert(Node node, ``int` `key) {` `    ``// if tree is empty return new node` `    ``if` `(node == ``null``)` `      ``return` `newNode(key);`   `    ``// if key is less than or greater than` `    ``// node value then recur down the tree` `    ``if` `(key < node.key)` `      ``node.left = insert(node.left, key);` `    ``else` `if` `(key > node.key)` `      ``node.right = insert(node.right, key);`   `    ``// return the (unchanged) node pointer` `    ``return` `node;` `  ``}`   `  ``// function to find max value less than N` `  ``static` `void` `findMaxforN(Node root, ``int` `N) {` `    ``// Start from root and keep looking for larger` `    ``while` `(root != ``null` `&& root.right != ``null``) {`   `      ``// If root is smaller go to right side` `      ``if` `(N > root.key && N >= root.right.key)` `        ``root = root.right;`   `      ``// If root is greater go to left side` `      ``else` `if` `(N < root.key)` `        ``root = root.left;`   `      ``else` `        ``break``;` `    ``}` `    ``if` `(root == ``null` `|| root.key > N)` `      ``Console.Write(-1);` `    ``else` `      ``Console.Write(root.key);` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main(String[] args) {` `    ``int` `N = 50;` `    ``Node root = insert(``null``, 5);` `    ``insert(root, 2);` `    ``insert(root, 1);` `    ``insert(root, 3);` `    ``insert(root, 12);` `    ``insert(root, 9);` `    ``insert(root, 21);` `    ``insert(root, 19);` `    ``insert(root, 25);`   `    ``findMaxforN(root, N);` `  ``}` `}`   `// This code is contributed by Rajput-Ji `

## Javascript

 ``

Output

`25`

Time Complexity: O(h), where h is height of BST.
Auxiliary Space: O(1), As constant extra space is used.

This article is contributed by Niteesh Kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up
Related Articles