Open In App

# Java program to Find the Square Root of a Number using Binary Search

Given a non-negative number find the square root of a number using the binary search approach.

Examples :

```Input: x = 16
Output: 4
Explanation:  The square root of 16 is 4.

Input: x = 5
Output: 2
Explanation:  The square root of 5 lies in between
2 and 3 so floor of the square root is 2.```

Naive Approach:

• Check the square of every element till n and store the answer till the square is smaller or equal to the n

## Java

 `// Java program to Find the square root of given numbers``// by brute force technique` `import` `java.io.*;` `class` `GFG {``    ``static` `int` `cuberoot(``int` `n)``    ``{``        ``int` `ans = ``0``;` `        ``for` `(``int` `i = ``1``; i <= n; ++i) {``          ` `            ``// checking every number cube``            ``if` `(i * i <= n) {``                ``ans = i;``            ``}``        ``}``        ``return` `ans;``    ``}``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Number``        ``int` `number = ``16``;``      ` `        ``// Checking number``        ``int` `cuberoot = cuberoot(number);``        ``System.out.println(cuberoot);``    ``}``}`

Output

`4`

SpaceComplexity: O(1)

TimeComplexity: O(n)

Efficient Approach (Binary Search): Binary Search used Divide and Conquer approach that makes the complexity is O(logn).

Algorithm:

• Initialize left=0 and right =n
• Calculate mid=left+(right-left)/2
• If mid*mid is equal to the number return the mid.
• If mid*mid is less than the number store the mid in ans since this can possibly be the answer and increase left=mid+1 and now check in the right half.
• If mid*mid is more than the number and decrease the right=mid-1 since the expected value is lesser therefore we will now look into the left half part or will be scanning the smaller values.

Implementation:

## Java

 `// Java program to Find the square root of given numbers``// using Binary search` `// Importing libraries``import` `java.io.*;``import` `java.util.*;``class` `GFG {``  ` `    ``// Function to find cuberoot``    ``static` `int` `squareeroot(``int` `number)``    ``{``        ``// Lower bound``        ``int` `left = ``1``;``      ` `        ``// Upper bound``        ``int` `right = number;` `        ``int` `ans = ``0``;``        ``while` `(left <= right) {``          ` `            ``// Finding the mid value` `            ``int` `mid = left + (right - left) / ``2``;``          ` `            ``// Checking the mid value``            ``if` `(mid * mid == number) {``                ``return` `mid;``            ``}` `            ``// Shift the lower bound``            ``if` `(mid * mid < number) {``                ``left = mid + ``1``;``                ``ans = mid;``            ``}``          ` `            ``// Shift the upper bound``            ``else` `{``                ``right = mid - ``1``;``            ``}``        ``}``      ` `        ``// Return the ans``        ``return` `ans;``    ``}``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `number = ``15``;``        ``System.out.println(squareroot(number));``    ``}``}`

Output

`3`

Time Complexity: O(logn)

Auxiliary space: O(1) as it is using constant variables