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

2

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.
BST

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)

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.

// C++ code to find the largest value smaller
// than or equal to N
#include <bits/stdc++.h>
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 then or grater then
    // 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 then N
int findMaxforN(Node* root, int N)
{
    /* If leaf node reached and is greater than N*/
    if (root->left == NULL && root->right == NULL && 
        root->key > N)
        return -1;

    /* If node's value is less than N and right value
       is NULL or grater than then return the node 
       value*/
    if ((root->key <= N && root->right == NULL) || 
        (root->key <= N && root->right->key > N))
        return root->key;

    // if node value is grater than N search in the
    // left subtree
    if (root->key >= N)
        return findMaxforN(root->left, N);

    // if node value is less than N search in the
    // right subtree
    else
        return findMaxforN(root->right, 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;
}

Output:

3

Time complexity = O(h) where h is height of BST.

Reference :
https://www.careercup.com/question?id=5765237112307712

This article is contributed by Niteesh Kumar. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.

Recommended Posts:



2 Average Difficulty : 2/5.0
Based on 9 vote(s)










Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.