Floor square root without using sqrt() function : Recursive

28 Dec, 2021
Given a number N, the task is to find the floor square root of the number N without using the built-in square root function. Floor square root of a number is the greatest whole number which is less than or equal to its square root.
Examples:  
Input: N = 25 Output: 5 Explanation: Square root of 25 = 5. Therefore 5 is the greatest whole number less than equal to Square root of 25. 
Input: N = 30 Output: 5 Explanation: Square root of 30 = 5.47 Therefore 5 is the greatest whole number less than equal to Square root of 30(5.47)  
Naive Approach: In the basic approach to find the floor square root of a number, find the square of numbers from 1 to N, till the square of some number K becomes greater than N. Hence the value of (K – 1) will be the floor square root of N.
Below is the algorithm to solve this problem using Naive approach: 
Iterate a loop from numbers 1 to N in K.
For any K, if its square becomes greater than N, then K-1 is the floor square root of N.
Time Complexity: O(√N)
Efficient Approach: From the Naive approach, it is clear that the floor square root of N will lie in the range [1, N]. Hence instead of checking each number in this range, we can efficiently search the required number in this range. Therefore, the idea is to use the binary search in order to efficiently find the floor square root of the number N in log N.
Below is the recursive algorithm to solve the above problem using Binary Search: 
Implement the Binary Search in the range 0 to N.
Find the mid value of the range using formula:
mid = (start + end) / 2
Base Case: The recursive call will get executed till square of mid is less than or equal to N and the square of (mid+1) is greater than equal to N.
(mid2 ≤ N) and ((mid + 1)2 > N)
If the base case is not satisfied, then the range will get changed accordingly. If the square of mid is less than equal to N, then the range gets updated to [mid + 1, end]
If the square of mid is less than equal to N, then the range gets updated to [mid + 1, end]
if(mid2 ≤ N)
    updated range = [mid + 1, end]
If the square of mid is greater than N, then the range gets updated to [low, mid + 1]
if(mid2 > N)
    updated range = [low, mid - 1]
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ implementation to find the// square root of the number N// without using sqrt() function #include <bits/stdc++.h>using namespace std; // Function to find the square// root of the number N using BSint sqrtSearch(int low, int high, int N){     // If the range is still valid    if (low <= high) {         // Find the mid-value of the range        int mid = (low + high) / 2;         // Base Case        if ((mid * mid <= N)            && ((mid + 1) * (mid + 1) > N)) {            return mid;        }         // Condition to check if the        // left search space is useless        else if (mid * mid < N) {            return sqrtSearch(mid + 1, high, N);        }        else {            return sqrtSearch(low, mid - 1, N);        }    }    return low;} // Driver Codeint main(){    int N = 25;    cout << sqrtSearch(0, N, N)         << endl;    return 0;}
// Java implementation to find the// square root of the number N// without using sqrt() functionclass GFG {         // Function to find the square    // root of the number N using BS    static int sqrtSearch(int low, int high, int N)    {             // If the range is still valid        if (low <= high) {                 // Find the mid-value of the range            int mid = (int)(low + high) / 2;                 // Base Case            if ((mid * mid <= N)                && ((mid + 1) * (mid + 1) > N)) {                return mid;            }                 // Condition to check if the            // left search space is useless            else if (mid * mid < N) {                return sqrtSearch(mid + 1, high, N);            }            else {                return sqrtSearch(low, mid - 1, N);            }        }        return low;    }         // Driver Code    public static void main (String[] args)    {        int N = 25;        System.out.println(sqrtSearch(0, N, N));    }} // This code is contributed by Yash_R
# Python3 implementation to find the# square root of the number N# without using sqrt() function # Function to find the square# root of the number N using BSdef sqrtSearch(low, high, N) :     # If the range is still valid    if (low <= high) :         # Find the mid-value of the range        mid = (low + high) // 2;         # Base Case        if ((mid * mid <= N) and ((mid + 1) * (mid + 1) > N)) :            return mid;         # Condition to check if the        # left search space is useless        elif (mid * mid < N) :            return sqrtSearch(mid + 1, high, N);             else :            return sqrtSearch(low, mid - 1, N);     return low; # Driver Codeif __name__ == "__main__" :     N = 25;    print(sqrtSearch(0, N, N)) # This code is contributed by Yash_R
// C# implementation to find the// square root of the number N// without using sqrt() functionusing System; class GFG {          // Function to find the square    // root of the number N using BS    static int sqrtSearch(int low, int high, int N)    {              // If the range is still valid        if (low <= high) {                  // Find the mid-value of the range            int mid = (int)(low + high) / 2;                  // Base Case            if ((mid * mid <= N)                && ((mid + 1) * (mid + 1) > N)) {                return mid;            }                  // Condition to check if the            // left search space is useless            else if (mid * mid < N) {                return sqrtSearch(mid + 1, high, N);            }            else {                return sqrtSearch(low, mid - 1, N);            }        }        return low;    }          // Driver Code    public static void Main(String[] args)    {        int N = 25;        Console.WriteLine(sqrtSearch(0, N, N));    }} // This code is contributed by PrinciRaj1992
<script> // Javascript implementation to find the// square root of the number N// without using sqrt() function // Function to find the square// root of the number N using BSfunction sqrtSearch(low, high, N){         // If the range is still valid    if (low <= high)    {                 // Find the mid-value of the range        var mid = parseInt( (low + high) / 2);         // Base Case        if ((mid * mid <= N) &&           ((mid + 1) * (mid + 1) > N))        {            return mid;        }         // Condition to check if the        // left search space is useless        else if (mid * mid < N)        {            return sqrtSearch(mid + 1, high, N);        }        else        {            return sqrtSearch(low, mid - 1, N);        }    }    return low;} // Driver Codevar N = 25; document.write(sqrtSearch(0, N, N)); // This code is contributed by todaysgaurav </script>
5
 
Performance Analysis: 
Time Complexity: As in the above approach, there is Binary Search used over the search space of 0 to N which takes O(log N) time in worst case, Hence the Time Complexity will be O(log N).
Space Complexity: As in the above approach, taking consideration of the stack space used in the recursive calls which can take O(logN) space in worst case, Hence the space complexity will be O(log N)
 
Yash_R
princiraj1992
nidhi_biet
todaysgaurav
shashankskb18700
Binary Search
maths-perfect-square
root
Algorithms
Mathematical
Mathematical
Binary Search
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
DSA Sheet by Love Babbar
SDE SHEET - A Complete Guide for SDE Preparation
What is Hashing | A Complete Tutorial
Understanding Time Complexity with Simple Examples
Find if there is a path between two vertices in an undirected graph
Program for Fibonacci numbers
Set in C++ Standard Template Library (STL)
Write a program to print all permutations of a given string
C++ Data Types
Merge two sorted arrays