Binary search is a popular method of searching in a sorted array or list. It simply divides the list into two halves and discards the half which has zero probability of having the key. On dividing, we check the midpoint for the key and use the lower half if the key is less than the midpoint and the upper half if the key is greater than the midpoint. Binary search has a time complexity of O(log(n)). Binary search can also be implemented using multi-threading where we utilize the cores of the processor by providing each thread a portion of the list to search for the key. The number of threads depends upon the number of cores your processor has and it’s better to create one thread for each core. Examples:
Input : list = 1, 5, 7, 10, 12, 14, 15, 18, 20, 22, 25, 27, 30, 64, 110, 220
key = 7
Output : 7 found in list
Input : list = 1, 5, 7, 10, 12, 14, 15, 18, 20, 22, 25, 27, 30, 64, 110, 220
key = 111
Output : 111 not found in list
Note – It is advised to execute the program in Linux based system. Compile in Linux using the following code:
g++ -pthread program_name.cpp
CPP
#include <iostream>
using namespace std;
#define MAX 16
#define MAX_THREAD 4
int a[] = { 1, 5, 7, 10, 12, 14, 15, 18,
20, 22, 25, 27, 30, 64, 110, 220 };
int key = 110;
bool found = false ;
int part = 0;
void * binary_search( void * arg)
{
int thread_part = part++;
int mid;
int low = thread_part * (MAX / 4);
int high = (thread_part + 1) * (MAX / 4);
while (low < high && !found) {
mid = (high - low) / 2 + low;
if (a[mid] == key) {
found = true ;
break ;
}
else if (a[mid] > key)
high = mid - 1;
else
low = mid + 1;
}
}
int main()
{
pthread_t threads[MAX_THREAD];
for ( int i = 0; i < MAX_THREAD; i++)
pthread_create(&threads[i], NULL, binary_search,
( void *)NULL);
for ( int i = 0; i < MAX_THREAD; i++)
pthread_join(threads[i], NULL);
if (found)
cout << key << " found in array" << endl;
else
cout << key << " not found in array" << endl;
return 0;
}
|
Java
import java.util.concurrent.atomic.AtomicInteger;
public class Program {
static final int MAX = 16 ;
static final int MAX_THREAD = 4 ;
static int [] arr = { 1 , 5 , 7 , 10 , 12 , 14 , 15 , 18 ,
20 , 22 , 25 , 27 , 30 , 64 , 110 , 220 };
static int key = 110 ;
static boolean found = false ;
static AtomicInteger part = new AtomicInteger( 0 );
static void binarySearch()
{
int thread_part = part.getAndIncrement();
int low = thread_part * (MAX / 4 );
int high = (thread_part + 1 ) * (MAX / 4 );
while (low < high && !found) {
int mid = low + (high - low) / 2 ;
if (arr[mid] == key) {
found = true ;
break ;
}
else if (arr[mid] > key) {
high = mid - 1 ;
}
else {
low = mid + 1 ;
}
}
}
public static void main(String[] args)
{
Thread[] thread = new Thread[MAX_THREAD];
for ( int i = 0 ; i < MAX_THREAD; i++) {
thread[i]
= new Thread( new Runnable() {
public void run() {
binarySearch();
}
});
thread[i].start();
}
for ( int i = 0 ; i < MAX_THREAD; i++) {
try {
thread[i].join();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
if (found) {
System.out.printf( "%d found in array\n" , key);
}
else {
System.out.printf( "%d not found in array\n" ,key);
}
}
}
|
Python3
from threading import Thread
MAX = 16
MAX_THREAD = 4
arr = [ 1 , 5 , 7 , 10 , 12 , 14 , 15 , 18 ,
20 , 22 , 25 , 27 , 30 , 64 , 110 , 220 ]
key = 110
found = False
part = 0
def binary_search():
global part, found
thread_part = part
part + = 1
low = int (thread_part * ( MAX / 4 ))
high = int ((thread_part + 1 ) * ( MAX / 4 ))
while (low < high and not found):
mid = int (low + (high - low) / 2 )
if arr[mid] = = key:
found = True
break
elif arr[mid] > key:
high = mid - 1
else :
low = mid + 1
if __name__ = = "__main__" :
thread = list ( range (MAX_THREAD))
for i in range (MAX_THREAD):
thread[i] = Thread(target = binary_search)
thread[i].start()
for i in range (MAX_THREAD):
thread[i].join()
if found:
print ( "%d found in array" % key)
else :
print ( "%d not found in array" % key)
|
C#
using System;
using System.Threading;
public class Program {
const int MAX = 16;
const int MAX_THREAD = 4;
static int [] arr = { 1, 5, 7, 10, 12, 14, 15, 18,
20, 22, 25, 27, 30, 64, 110, 220 };
static int key = 110;
static bool found = false ;
static int part = 0;
static void BinarySearch()
{
int thread_part
= Interlocked.Increment( ref part) - 1;
int low = thread_part * (MAX / 4);
int high = (thread_part + 1) * (MAX / 4);
while (low < high && !found) {
int mid = low + (high - low) / 2;
if (arr[mid] == key) {
found = true ;
break ;
}
else if (arr[mid] > key) {
high = mid - 1;
}
else {
low = mid + 1;
}
}
}
static void Main()
{
Thread[] thread = new Thread[MAX_THREAD];
for ( int i = 0; i < MAX_THREAD; i++) {
thread[i]
= new Thread( new ThreadStart(BinarySearch));
thread[i].Start();
}
for ( int i = 0; i < MAX_THREAD; i++) {
thread[i].Join();
}
if (found) {
Console.WriteLine( "{0} found in array" , key);
}
else {
Console.WriteLine( "{0} not found in array" ,
key);
}
}
}
|
Javascript
const MAX = 16;
const MAX_THREAD = 4;
const arr = [1, 5, 7, 10, 12, 14, 15, 18,
20, 22, 25, 27, 30, 64, 110, 220];
const key = 110;
let found = false ;
let part = 0;
function binarySearch() {
const threadPart = part;
part += 1;
let low = Math.floor(threadPart * (MAX / 4));
let high = Math.floor((threadPart + 1) * (MAX / 4));
while (low < high && !found) {
const mid = Math.floor(low + (high - low) / 2);
if (arr[mid] === key) {
found = true ;
break ;
} else if (arr[mid] > key) {
high = mid - 1;
} else {
low = mid + 1;
}
}
}
const threads = new Array(MAX_THREAD).fill( null ).map(() => {
return new Promise(resolve => {
binarySearch();
resolve();
});
});
Promise.all(threads).then(() => {
if (found) {
console.log(`${key} found in array`);
} else {
console.log(`${key} not found in array`);
}
});
|
Output
110 found in array
Time complexity: O(log(n))
Space complexity: O(1)