# DSA using Java - Binary Search

## Overview

Binary search is a very fast search algorithm. This search algorithm works on the principle of divide and conquer. For this algorithm to work properly the data collection should be in sorted form.

Binary search search a particular item by comparing the middle most item of the collection. If match occurs then index of item is returned. If middle item is greater than item then item is searched in sub-array to the right of the middle item other wise item is search in sub-array to the left of the middle item. This process continues on sub-array as well until the size of subarray reduces to zero.

Binary search halves the searchable items and thus reduces the count of comparisons to be made to very less numbers.

## Algorithm

```Binary Search ( A: array of item, n: total no. of items ,x: item to be searched)
Step 1: Set lowerBound = 1
Step 2: Set upperBound = n
Step 3: if upperBound < lowerBound go to step 12
Step 4: set midPoint = ( lowerBound + upperBound ) / 2
Step 5: if A[midPoint] < x
Step 6: set lowerBound = midPoint + 1
Step 7: if A[midPoint] > x
Step 8: set upperBound = midPoint - 1
Step 9  if A[midPoint] = x go to step 11
Step 10: Go to Step 3
Step 11: Print Element x Found at index midPoint and go to step 13
Step 13: Exit
```

## Demo Program

```package com.tutorialspoint.simplesearch;

import java.util.Arrays;

public class BinarySearchDemo {

public static void main(String args[]){
int[] sourceArray = {1,2,3,4,6,7,9,11,12,14,15,
16,17,19,33,34,43,45,55,66,76,88};
System.out.println("Input Array: " +Arrays.toString(sourceArray));
printline(50);
// find location of 55
int location = find(sourceArray, 55);
if(location != -1){
System.out.println("Element found at location: " +(location+1));
}else {
}
}

public static int find(int[] intArray, int data){
int lowerBound = 0;
int upperBound = intArray.length -1;
int midPoint = -1;
int comparisons = 0;
int index = -1;
while(lowerBound <= upperBound){
System.out.println("Comparison " + (comparisons +1) ) ;
System.out.println("lowerBound : "+lowerBound
+ " , intArray[" + lowerBound+"] = "
+ intArray[lowerBound]) ;
System.out.println("upperBound : "+upperBound
+ " , intArray[" + upperBound+"] = "
+ intArray[upperBound]) ;
comparisons++;
// compute the mid point
midPoint = (lowerBound + upperBound) / 2;
// data found
if(intArray[midPoint] == data){
index = midPoint;
break;
}
else {
// if data is larger
if(intArray[midPoint] < data){
// data is in upper half
lowerBound = midPoint + 1;
}
// data is smaller
else{
// data is in lower half
upperBound = midPoint -1;
}
}
}
System.out.println("Total comparisons made: " + comparisons);
return index;
}

public static void printline(int count){
for(int i=0;i <count-1;i++){
System.out.print("=");
}
System.out.println("=");
}
}
```

If we compile and run the above program then it would produce following result:

```Input Array: [1, 2, 3, 4, 6, 7, 9, 11, 12, 14, 15, 16, 17, 19, 33, 34, 43, 45, 55, 66, 76, 88]
==================================================
Comparison 1
lowerBound : 0 , intArray = 1
upperBound : 21 , intArray = 88
Comparison 2
lowerBound : 11 , intArray = 16
upperBound : 21 , intArray = 88
Comparison 3
lowerBound : 17 , intArray = 45
upperBound : 21 , intArray = 88
Comparison 4
lowerBound : 17 , intArray = 45
upperBound : 18 , intArray = 55
Comparison 5
lowerBound : 18 , intArray = 55
upperBound : 18 , intArray = 55