Binary Search using pthread

Last Updated : 27 Dec, 2023

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 listInput :  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

// CPP Program to perform binary search using pthreads #include <iostream> using namespace std;  // size of array #define MAX 16  // maximum number of threads #define MAX_THREAD 4  // array to be searched int a[] = { 1,  5,  7,  10, 12, 14, 15,  18,             20, 22, 25, 27, 30, 64, 110, 220 };  // key that needs to be searched int key = 110; bool found = false; int part = 0;  void* binary_search(void* arg) {      // Each thread checks 1/4 of the array for the key     int thread_part = part++;     int mid;      int low = thread_part * (MAX / 4);     int high = (thread_part + 1) * (MAX / 4);      // search for the key until low < high     // or key is found in any portion of array     while (low < high && !found) {          // normal iterative binary search algorithm         mid = (high - low) / 2 + low;          if (a[mid] == key) {             found = true;             break;         }          else if (a[mid] > key)             high = mid - 1;         else             low = mid + 1;     } }  // Driver Code 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);      // key found in array     if (found)         cout << key << " found in array" << endl;      // key not found in array     else         cout << key << " not found in array" << endl;      return 0; }

Java

import java.util.concurrent.atomic.AtomicInteger;  public class Program {     // Size of array     static final int MAX = 16;     // Maximum number of threads     static final int MAX_THREAD = 4;     // Initial array     static int[] arr = { 1,  5,  7,  10, 12, 14, 15,  18,                          20, 22, 25, 27, 30, 64, 110, 220 };     // Key that needs to be searched     static int key = 110;     static boolean found = false;     static AtomicInteger part = new AtomicInteger(0);     // Function to perform Binary Search     static void binarySearch()     {         int thread_part = part.getAndIncrement();                  // Each thread checks 1/4 of the array for the key         int low = thread_part * (MAX / 4);         int high = (thread_part + 1) * (MAX / 4);         while (low < high && !found) {             // Normal iterative binary search algorithm             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;             }         }     }     // Driver Code     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);         }     } }  // This code is contributed by shivhack999

Python3

# Python3 Program to find sum of array # using multi-threading from threading import Thread  # Size of array MAX = 16 # Maximum number of threads MAX_THREAD = 4  # Initial array arr = [1, 5, 7, 10, 12, 14, 15, 18,        20, 22, 25, 27, 30, 64, 110, 220]  # Key that needs to be searched key = 110 found = False part = 0  # Function to perform Binary Search   def binary_search():     global part, found     thread_part = part     part += 1      # Each thread checks 1/4 of the array for the key     low = int(thread_part*(MAX/4))     high = int((thread_part+1)*(MAX/4))     # search for the key until low < high     # or key is found in any portion of array     while (low < high and not found):         # normal iterative binary search algorithm         mid = int(low + (high-low)/2)         if arr[mid] == key:             found = True             break         elif arr[mid] > key:             high = mid - 1         else:             low = mid + 1   # Driver Code if __name__ == "__main__":         # Creating list of size MAX_THREAD     thread = list(range(MAX_THREAD))     # Creating MAX_THEAD number of threads     for i in range(MAX_THREAD):         thread[i] = Thread(target=binary_search)         thread[i].start()      # Waiting for all threads to finish     for i in range(MAX_THREAD):         thread[i].join()      # Key found in array     if found:         print("%d found in array" % key)     else:         print("%d not found in array" % key)

using System; using System.Threading;  public class Program {     // Size of array     const int MAX = 16;     // Maximum number of threads     const int MAX_THREAD = 4;     // Initial array     static int[] arr = { 1,  5,  7,  10, 12, 14, 15,  18,                          20, 22, 25, 27, 30, 64, 110, 220 };     // Key that needs to be searched     static int key = 110;     static bool found = false;     static int part = 0;      // Function to perform Binary Search     static void BinarySearch()     {         int thread_part             = Interlocked.Increment(ref part) - 1;          // Each thread checks 1/4 of the array for the key         int low = thread_part * (MAX / 4);         int high = (thread_part + 1) * (MAX / 4);          // Search for the key until low < high         // or key is found in any portion of array         while (low < high && !found) {             // Normal iterative binary search algorithm             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;             }         }     }      // Driver Code     static void Main()     {         // Creating array of size MAX_THREAD         Thread[] thread = new Thread[MAX_THREAD];         // Creating MAX_THREAD number of threads         for (int i = 0; i < MAX_THREAD; i++) {             thread[i]                 = new Thread(new ThreadStart(BinarySearch));             thread[i].Start();         }          // Waiting for all threads to finish         for (int i = 0; i < MAX_THREAD; i++) {             thread[i].Join();         }          // Key found in array         if (found) {             Console.WriteLine("{0} found in array", key);         }         else {             Console.WriteLine("{0} not found in array",                               key);         }     } } // This code is contributed by shiv1o43g

JavaScript

// Size of array const MAX = 16; // Maximum number of threads const MAX_THREAD = 4;  // Initial array const arr = [1, 5, 7, 10, 12, 14, 15, 18,     20, 22, 25, 27, 30, 64, 110, 220];  // Key that needs to be searched const key = 110; let found = false; let part = 0;  // Function to perform Binary Search function binarySearch() {     const threadPart = part;     part += 1;      // Each thread checks 1/4 of the array for the key     let low = Math.floor(threadPart * (MAX / 4));     let high = Math.floor((threadPart + 1) * (MAX / 4));      // Search for the key until low < high     // or key is found in any portion of the array     while (low < high && !found) {         // Normal iterative binary search algorithm         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;         }     } }  // Driver Code // Creating MAX_THREAD number of threads const threads = new Array(MAX_THREAD).fill(null).map(() => {     return new Promise(resolve => {         binarySearch();         resolve();     }); });  // Waiting for all threads to finish Promise.all(threads).then(() => {     // Key found in array     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)

Linear Search vs Binary Search

shubham_rana_77

Improve

Article Tags :

Practice Tags :

Binary Search using pthread

Similar Reads

Variants of Binary Search

Implementation of Binary Search in different languages

Comparison with other Searching