Skip to content

Binary Search (Recursive and Iterative) - Python

Binary Search in Java

Last Updated : 11 Apr, 2025

Try it on GfG Practice

Binary search is a highly efficient searching algorithm used when the input is sorted. It works by repeatedly dividing the search range in half, reducing the number of comparisons needed compared to a linear search. Here, we are focusing on finding the middle element that acts as a reference frame to determine whether to go left or right to it as the elements are already sorted This makes it ideal for large datasets, where it achieves a time complexity of O(log N) far faster than O(N) for sequential search.

Example Input/Output:

Input: arr = { 3, 5, 7, 8, 10, 12, 15}, target = 7
Output: 2
Input: arr = { 1, 2, 3, 4, 5, 6, 7, 8} target = 10
Output: -1 ( Because the target is not present in the array)

Key Points:

Sorted Array: Binary search only works on sorted arrays or lists. Unsorted inputs give undefined results.
Duplicate Values: If duplicates exist, the returned index depends on the implementation (e.g., it may return the first or any occurrence).
Efficient: Binary search is efficient for a large dataset if the given input is sorted. Always refer to binary search over sequential search.

Binary Search Algorithm in Java

Below is the Algorithm designed for Binary Search:

Start
Take input array and Target
Initialise start = 0 and end = (array size -1)
Intialise mid variable
mid = (start+end)/2
if array[ mid ] == target then return mid
if array[ mid ] < target then start = mid+1
if array[ mid ] > target then end = mid-1
if start<=end then goto step 5
return -1 as target not found
Exit

Now you must be thinking what if the input is not sorted then the results are undefined.

Note: If there are duplicates, there is no guarantee which one will be found.

Importance of Binary Search

It eliminates half the remaining elements in each step, making it optimal for large datasets.
It is used in databases, search algorithms, and performance critical applications.

Methods for Java Binary Search

There are three methods in Java to implement Binary Search in Java are mentioned below:

Iterative Method
Recursive Method
Inbuild Method

1. Iterative Method for Binary Search in Java

Example: Binary Search program using iterative method.

Java

// Java implementation of iterative Binary Search class Geeks {    static int binarySearch(int a[], int l, int r, int x)     {         while (l <= r) {             int m = (l + r) / 2;              // Index of Element Returned             if (a[m] == x) {                 return m;              // If element is smaller than mid, then             // it can only be present in left subarray             // so we decrease our r pointer to mid - 1              } else if (a[m] > x) {                 r = m - 1;              // Else the element can only be present             // in right subarray             // so we increase our l pointer to mid + 1             } else {               l = m + 1;             }           }          // No Element Found         return -1;     }      public static void main(String args[])     {          int a[] = { 2, 3, 4, 10, 40 };         int n = a.length;         int x = 10;                int res = binarySearch(a, 0, n - 1, x);           System.out.println("Element to be searched is : "+ x);           if (res == -1)             System.out.println("Element is not present in array");         else             System.out.println("Element is present at index: " + res);     } }

Output

Element to be searched is : 10 Element is present at index: 3

Tip: Geeks you must be wondering out whether there is any function like lower_bound() or upper_bound() just likely found in C++ STL. so the straight answer is that there was no function only till Java 9, later onwards they were added.

2. Recursive Method for Binary Search

Example: Binary Search program using recursion.

Java

// Java implementation of // recursive Binary Search public class Geeks {     static int binarySearch(int a[], int l, int r, int x)     {        	if (r >= l) {             int m = l + (r - l) / 2;              // Returned Index of the Element             if (a[m] == x)                 return m;              // If element is smaller than mid, then             // it can only be present in left subarray             if (a[m] > x)                 return binarySearch(a, l, m - 1, x);              // Else the element can only be present             // in right subarray             return binarySearch(a, m + 1, r, x);         }          // No Element Found         return -1;     }      // main function     public static void main(String args[])     {         int a[] = { 2, 3, 4, 10, 40 };         int n = a.length;         int x = 10;                int res = binarySearch(a, 0, n - 1, x);         System.out.println("Element to be searched is : "+ x);           if (res == -1)             System.out.println(                 "Element is not present in array");         else             System.out.println("Element is present at index: " + res);     } }

Output

Element to be searched is : 10 Element is present at index: 3

Complexity of the above method

Time Complexity: O(log N)
Space Complexity: O(1), If the recursive call stack is considered then the auxiliary space will be O(log N)

3. In Build Method for Binary Search in Java

Arrays.binarysearch() works for arrays which can be of primitive data type also.

Example: Binary Search program in Java using in-build method Arrays.binarysearch().

Java

// Java Program to demonstrate working of binarySearch() // Method of Arrays class In a sorted array import java.util.Arrays;  public class Geeks {      public static void main(String[] args)     {       	int a[] = { 10, 20, 15, 22, 35 };          // Sorting the above array         // using sort() method of Arrays class         Arrays.sort(a);          int x = 22;                	int res = Arrays.binarySearch(a, x);                   System.out.println("Element to be searched is : "+ x);                   if (res >= 0)             System.out.println(x + " found at index = " + res);         else             System.out.println(x + " Not found");          x = 40;         res = Arrays.binarySearch(a, x);                	System.out.println("Element to be searched is : "+ x);         if (res >= 0)             System.out.println(x + " found at index = " + res);         else             System.out.println(x + " Not found");     } }

Output

Element to be searched is : 22 22 found at index = 3 Element to be searched is : 40 40 Not found

Binary Search in Java Collections

Now let us see how Collections.binarySearch() work for LinkedList. So basically as discussed above this method runs in log(n) time for a "random access" list like ArrayList. If the specified list does not implement the RandomAccess interface and is large, this method will do an iterator-based binary search that performs O(n) link traversals and O(log n) element comparisons.

Collections.binarysearch() works for objects Collections like ArrayList and LinkedList.

Example: Binary Search using Collection.binarysearch() on arraylist and linkedlist.

Java

// Java Program to Demonstrate Working of binarySearch() // method of Collections class import java.util.ArrayList; import java.util.Collections; import java.util.List;  public class Geeks {     public static void main(String[] args)     {        	List<Integer> a = new ArrayList<Integer>();          // Populating the Arraylist         a.add(1);         a.add(2);         a.add(3);         a.add(10);         a.add(20);          int x = 10;         int res = Collections.binarySearch(a, x);                  System.out.println("Element to be searched is : "+ x);                  if (res >= 0)             System.out.println(x + " found at index = " + res);         else             System.out.println(x + " Not found");          x = 15;         res = Collections.binarySearch(a, x);          if (res >= 0)             System.out.println(x + " found at index = " + res);         else             System.out.println(x + " Not found");     } }

Output

Element to be searched is : 10 10 found at index = 3 15 Not found

The complexity of the above method:

Time complexity: O(log N)
Auxiliary space: O(1)

Binary Search (Recursive and Iterative) - Python

K

kartik

Improve

Article Tags :

Practice Tags :

Similar Reads

Binary Search Algorithm - Iterative and Recursive Implementation

Binary Search Algorithm is a searching algorithm used in a sorted array by repeatedly dividing the search interval in half. The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N). Binary Search AlgorithmConditions to apply Binary Searc

What is Binary Search Algorithm?

Binary Search is a searching algorithm used in a sorted array by repeatedly dividing the search interval in half and the correct interval to find is decided based on the searched value and the mid value of the interval. Example of binary searchProperties of Binary Search:Binary search is performed o

Time and Space Complexity Analysis of Binary Search Algorithm

Time complexity of Binary Search is O(log n), where n is the number of elements in the array. It divides the array in half at each step. Space complexity is O(1) as it uses a constant amount of extra space. Example of Binary Search AlgorithmAspectComplexityTime ComplexityO(log n)Space ComplexityO(1)

How to calculate "mid" or Middle Element Index in Binary Search?

The most common method to calculate mid or middle element index in Binary Search Algorithm is to find the middle of the highest index and lowest index of the searchable space, using the formula mid = low + \frac{(high - low)}{2} Finding the middle index "mid" in Binary Search AlgorithmIs this method

Binary Search Intuition and Predicate Functions

The binary search algorithm is used in many coding problems, and it is usually not very obvious at first sight. However, there is certainly an intuition and specific conditions that may hint at using binary search. In this article, we try to develop an intuition for binary search. Introduction to Bi

Can Binary Search be applied in an Unsorted Array?

Binary Search is a search algorithm that is specifically designed for searching in sorted data structures. This searching algorithm is much more efficient than Linear Search as they repeatedly target the center of the search structure and divide the search space in half. It has logarithmic time comp

Find a String in given Array of Strings using Binary Search

Given a sorted array of Strings arr and a string x, The task is to find the index of x in the array using the Binary Search algorithm. If x is not present, return -1.Examples:Input: arr[] = {"contribute", "geeks", "ide", "practice"}, x = "ide"Output: 2Explanation: The String x is present at index 2.