// C++ program to implement iterative Binary Search #include  using namespace std; // An iterative binary search function. int binarySearch(int arr[], int low, int high, int x) {  while (low <= high) {  int mid = low + (high - low) / 2;  // Check if x is present at mid  if (arr[mid] == x)  return mid;  // If x greater, ignore left half  if (arr[mid] < x)  low = mid + 1;  // If x is smaller, ignore right half  else  high = mid - 1;  }  // If we reach here, then element was not present  return -1; } // Driver code int main(void) {  int arr[] = { 2, 3, 4, 10, 40 };  int x = 10;  int n = sizeof(arr) / sizeof(arr[0]);  int result = binarySearch(arr, 0, n - 1, x);  (result == -1)  ? cout << 'Element is not present in array'  : cout << 'Element is present at index ' << result;  return 0; }>

// C program to implement iterative Binary Search #include  // An iterative binary search function. int binarySearch(int arr[], int low, int high, int x) {  while (low <= high) {  int mid = low + (high - low) / 2;  // Check if x is present at mid  if (arr[mid] == x)  return mid;  // If x greater, ignore left half  if (arr[mid] < x)  low = mid + 1;  // If x is smaller, ignore right half  else  high = mid - 1;  }  // If we reach here, then element was not present  return -1; } // Driver code int main(void) {  int arr[] = { 2, 3, 4, 10, 40 };  int n = sizeof(arr) / sizeof(arr[0]);  int x = 10;  int result = binarySearch(arr, 0, n - 1, x);  (result == -1) ? printf('Element is not present'  ' in array')  : printf('Element is present at '  'index %d',  result);  return 0; }>

// Java implementation of iterative Binary Search import java.io.*; class BinarySearch {    // Returns index of x if it is present in arr[].  int binarySearch(int arr[], int x)  {  int low = 0, high = arr.length - 1;  while (low <= high) {  int mid = low + (high - low) / 2;  // Check if x is present at mid  if (arr[mid] == x)  return mid;  // If x greater, ignore left half  if (arr[mid] < x)  low = mid + 1;  // If x is smaller, ignore right half  else  high = mid - 1;  }  // If we reach here, then element was  // not present  return -1;  }  // Driver code  public static void main(String args[])  {  BinarySearch ob = new BinarySearch();  int arr[] = { 2, 3, 4, 10, 40 };  int n = arr.length;  int x = 10;  int result = ob.binarySearch(arr, x);  if (result == -1)  System.out.println(  'Element is not present in array');  else  System.out.println('Element is present at '  + 'index ' + result);  } }>

# Python3 code to implement iterative Binary # Search. # It returns location of x in given array arr def binarySearch(arr, low, high, x): while low <= high: mid = low + (high - low) // 2 # Check if x is present at mid if arr[mid] == x: return mid # If x is greater, ignore left half elif arr[mid] < x: low = mid + 1 # If x is smaller, ignore right half else: high = mid - 1 # If we reach here, then the element # was not present return -1 # Driver Code if __name__ == '__main__': arr = [2, 3, 4, 10, 40] x = 10 # Function call result = binarySearch(arr, 0, len(arr)-1, x) if result != -1: print('Element is present at index', result) else: print('Element is not present in array')>

// C# implementation of iterative Binary Search using System; class GFG {    // Returns index of x if it is present in arr[]  static int binarySearch(int[] arr, int x)  {  int low = 0, high = arr.Length - 1;  while (low <= high) {  int mid = low + (high - low) / 2;  // Check if x is present at mid  if (arr[mid] == x)  return mid;  // If x greater, ignore left half  if (arr[mid] < x)  low = mid + 1;  // If x is smaller, ignore right half  else  high = mid - 1;  }  // If we reach here, then element was  // not present  return -1;  }  // Driver code  public static void Main()  {  int[] arr = { 2, 3, 4, 10, 40 };  int n = arr.Length;  int x = 10;  int result = binarySearch(arr, x);  if (result == -1)  Console.WriteLine(  'Element is not present in array');  else  Console.WriteLine('Element is present at '  + 'index ' + result);  } }>

// Program to implement iterative Binary Search   // A iterative binary search function. It returns // location of x in given array arr[l..r] is present, // otherwise -1  function binarySearch(arr, x) {   let low = 0;  let high = arr.length - 1;  let mid;  while (high>= zems) { vid. = zems + Math.floor((augsts - zems) / 2);    // Ja elements atrodas vidū // pats if (arr[mid] == x) return mid;    // Ja elements ir mazāks par vidu, tad // tas var būt tikai kreisajā apakšmasīvā, ja (arr[mid]> x) high = mid - 1;    // Citādi elements var būt tikai // labajā apakšgrupā else zems = mid + 1;  } // Mēs sasniedzam šeit, ja elementa nav // masīvā return -1; } arr =jauns masīvs(2, 3, 4, 10, 40);  x = 10;  n = arr.garums;  rezultāts = binarySearch(arr, x);   (rezultāts == -1) ? console.log('Elements nav masīvā') : console.log ('Elements atrodas indeksā ' + rezultāts);   // Šo kodu nodrošina simranarora5sos un rshuklabbb>

 // PHP program to implement // iterative Binary Search // An iterative binary search  // function function binarySearch($arr, $low, $high, $x) { while ($low <= $high) { $mid = $low + ($high - $low) / 2; // Check if x is present at mid if ($arr[$mid] == $x) return floor($mid); // If x greater, ignore // left half if ($arr[$mid] < $x) $low = $mid + 1; // If x is smaller,  // ignore right half else $high = $mid - 1; } // If we reach here, then  // element was not present return -1; } // Driver Code $arr = array(2, 3, 4, 10, 40); $n = count($arr); $x = 10; $result = binarySearch($arr, 0, $n - 1, $x); if(($result == -1)) echo 'Element is not present in array'; else echo 'Element is present at index ', $result; // This code is contributed by anuj_67. ?>>>  
  Izvade      Laika sarežģītība:    O(log N)  
    Palīgtelpa:    O(1)
 
    Rekursīvās binārās meklēšanas algoritms:    
 
Izveidojiet rekursīvu funkciju un salīdziniet meklēšanas telpas vidu ar taustiņu. Un, pamatojoties uz rezultātu, vai nu atgrieziet indeksu, kurā ir atrasta atslēga, vai izsauciet rekursīvo funkciju nākamajai meklēšanas vietai.
 
Rekursīvās binārās meklēšanas algoritma ieviešana:
java pievienošanas virkne
C++ 
#include  using namespace std; // A recursive binary search function. It returns // location of x in given array arr[low..high] is present, // otherwise -1 int binarySearch(int arr[], int low, int high, int x) {  if (high>= zems) { int mid = zems + (augsts - zems) / 2;  // Ja elements atrodas vidū // pats if (arr[mid] == x) return mid;  // Ja elements ir mazāks par vidu, tad // tas var būt tikai kreisajā apakšmasīvā, ja (arr[mid]> x) return binarySearch(arr, low, mid - 1, x);  // Citādi elements var būt tikai // labajā apakšslānī return binarySearch(arr, mid + 1, high, x);  } } // Draivera kods int main() { int arr[] = { 2, 3, 4, 10, 40 };  int vaicājums = 10;  int n = izmērs(arr) / izmērs(arr[0]);  int rezultāts = binarySearch(arr, 0, n - 1, vaicājums);  (rezultāts == -1) ? cout<< 'Element is not present in array'  : cout << 'Element is present at index ' << result;  return 0; }>
 C 
// C program to implement recursive Binary Search #include  // A recursive binary search function. It returns // location of x in given array arr[low..high] is present, // otherwise -1 int binarySearch(int arr[], int low, int high, int x) {  if (high>= zems) { int mid = zems + (augsts - zems) / 2;  // Ja elements atrodas vidū // pats if (arr[mid] == x) return mid;  // Ja elements ir mazāks par vidu, tad // tas var būt tikai kreisajā apakšmasīvā, ja (arr[mid]> x) return binarySearch(arr, low, mid - 1, x);  // Citādi elements var būt tikai // labajā apakšslānī return binarySearch(arr, mid + 1, high, x);  } // Mēs sasniedzam šeit, ja elementa nav // masīvā return -1; } // Draivera kods int main() { int arr[] = { 2, 3, 4, 10, 40 };  int n = izmērs(arr) / izmērs(arr[0]);  int x = 10;  int rezultāts = binarySearch(arr, 0, n - 1, x);  (rezultāts == -1) ? printf('Elements nav masīvā') : printf('Elements atrodas indeksā %d', rezultāts);  atgriezties 0; }>
 Java 
// Java implementation of recursive Binary Search class BinarySearch {  // Returns index of x if it is present in arr[low..  // high], else return -1  int binarySearch(int arr[], int low, int high, int x)  {  if (high>= zems) { int mid = zems + (augsts - zems) / 2;  // Ja elements atrodas pašā // vidū if (arr[mid] == x) return mid;  // Ja elements ir mazāks par vidu, tad // tas var atrasties tikai kreisajā apakšmasīvā, ja (arr[mid]> x) return binarySearch(arr, low, mid - 1, x);  // Citādi elements var būt tikai // labajā apakšslānī return binarySearch(arr, mid + 1, high, x);  } // Mēs sasniedzam šeit, kad elements nav klāt // masīvā return -1;  } // Draivera kods public static void main(String args[]) { BinarySearch ob = new BinarySearch();  int arr[] = {2, 3, 4, 10, 40};  int n = arr.garums;  int x = 10;  int rezultāts = ob.binarySearch(arr, 0, n - 1, x);  if (rezultāts == -1) System.out.println( 'Elements nav masīvā');  else System.out.println( 'Elements atrodas indeksā ' + rezultāts);  } } /* Šī koda autors ir Rajat Mishra */>
 Python 
# Python3 Program for recursive binary search. # Returns index of x in arr if present, else -1 def binarySearch(arr, low, high, x): # Check base case if high>= zems: vidējs = zems + (augsts - zems) // 2 # Ja elements atrodas pašā vidū if arr[mid] == x: return mid # Ja elements ir mazāks par vidu, tad tas # var būt tikai kreisajā apakšgrupā elif arr[mid]> x: return binarySearch(arr, low, mid-1, x) # Citādi elements var atrasties tikai # labajā apakšslānī else: return binarySearch(arr, mid + 1, high, x ) # Elements neatrodas masīvā else: return -1 # Draivera kods if __name__ == '__main__': arr = [2, 3, 4, 10, 40] x = 10 # Funkcijas izsaukuma rezultāts = binarySearch( arr, 0, len(arr)-1, x) ja rezultāts != -1: print('Elements atrodas indeksā', rezultāts) else: print('Elements nav masīvā')> 
 C# 
// C# implementation of recursive Binary Search using System; class GFG {  // Returns index of x if it is present in  // arr[low..high], else return -1  static int binarySearch(int[] arr, int low, int high, int x)  {  if (high>= zems) { int mid = zems + (augsts - zems) / 2;  // Ja elements atrodas pašā // vidū if (arr[mid] == x) return mid;  // Ja elements ir mazāks par vidu, tad // tas var būt tikai kreisajā apakšmasīvā, ja (arr[mid]> x) return binarySearch(arr, low, mid - 1, x);  // Citādi elements var būt tikai // labajā apakšslānī return binarySearch(arr, mid + 1, high, x);  } // Mēs sasniedzam šeit, kad elements nav klāt // masīvā return -1;  } // Draivera kods public static void Main() { int[] arr = { 2, 3, 4, 10, 40 };  int n = arr.Length;  int x = 10;  int rezultāts = binarySearch(arr, 0, n - 1, x);  if (rezultāts == -1) Console.WriteLine( 'Elements nav pieejams arrau');  else Console.WriteLine('Elements atrodas indeksā ' + rezultāts);  } } // Šo kodu nodrošina Sam007.>>Javascript>PHP>>  
  Izvade    Binārās meklēšanas algoritma sarežģītības analīze:  
    Laika sarežģītība:     
Labākais gadījums: O(1)
Vidējais gadījums: O(log N)
Sliktākais gadījums: O (log N)
    Palīgtelpa:    O(1), ja tiek ņemta vērā rekursīvā izsaukuma steka, tad palīgtelpa būs O(logN).
     Binārās meklēšanas algoritma pielietojumi:     
Bināro meklēšanu var izmantot kā pamatu sarežģītākiem algoritmiem, ko izmanto mašīnmācībā, piemēram, neironu tīklu apmācības algoritmiem vai modeļa optimālo hiperparametru atrašanai.
To var izmantot, lai meklētu datorgrafikā, piemēram, staru izsekošanas vai tekstūras kartēšanas algoritmos.
To var izmantot, lai meklētu datu bāzē.
    Binārās meklēšanas priekšrocības:    
Binārā meklēšana ir ātrāka nekā lineārā meklēšana, īpaši lieliem masīviem.
Efektīvāks nekā citi meklēšanas algoritmi ar līdzīgu laika sarežģītību, piemēram, interpolācijas meklēšana vai eksponenciālā meklēšana.
Binārā meklēšana ir labi piemērota lielu datu kopu meklēšanai, kas tiek glabātas ārējā atmiņā, piemēram, cietajā diskā vai mākonī.
    Binārās meklēšanas trūkumi:    
Masīvs ir jāsakārto.
Binārā meklēšana prasa, lai meklētā datu struktūra tiktu saglabāta blakus esošās atmiņas vietās.
Binārajai meklēšanai ir nepieciešams, lai masīva elementi būtu salīdzināmi, kas nozīmē, ka tiem ir jābūt iespējai sakārtot.
Bieži uzdotie jautājumi (FAQ) par bināro meklēšanu:
1. Kas ir binārā meklēšana?
 
Binārā meklēšana ir efektīvs algoritms mērķa vērtības atrašanai sakārtotā masīvā. Tas darbojas, atkārtoti dalot meklēšanas intervālu uz pusēm.
 
2. Kā darbojas binārā meklēšana?
 
Binārā meklēšana salīdzina mērķa vērtību ar masīva vidējo elementu. Ja tie ir vienādi, meklēšana ir veiksmīga. Ja mērķis ir mazāks par vidējo elementu, meklēšana turpinās masīva apakšējā daļā. Ja mērķis ir lielāks, meklēšana turpinās augšējā pusē. Šis process atkārtojas, līdz tiek atrasts mērķis vai meklēšanas intervāls ir tukšs.
 
3. Kāda ir binārās meklēšanas laika sarežģītība?
 
Binārās meklēšanas laika sarežģītība ir O(log2n), kur n ir elementu skaits masīvā. Tas ir tāpēc, ka katrā darbībā meklēšanas intervāla lielums tiek samazināts uz pusi.
 
4. Kādi ir binārās meklēšanas priekšnoteikumi?
 
Binārajai meklēšanai nepieciešams, lai masīvs būtu sakārtots augošā vai dilstošā secībā. Ja masīvs nav sakārtots, mēs nevaram izmantot bināro meklēšanu, lai meklētu elementu masīvā.
 
5. Kas notiek, ja masīvs nav sakārtots binārajai meklēšanai?
 
Ja masīvs nav sakārtots, binārā meklēšana var atgriezt nepareizus rezultātus. Tas balstās uz masīva sakārtoto raksturu, lai pieņemtu lēmumus par to, kurā masīva pusē meklēt.
 
6. Vai bināro meklēšanu var attiecināt uz datiem, kas nav skaitļi?
 
Jā, bināro meklēšanu var lietot datiem, kas nav skaitļi, ja vien elementiem ir noteikta secība. Piemēram, to var izmantot, lai meklētu virknes alfabēta secībā.
 
7. Kādi ir daži izplatītākie binārās meklēšanas trūkumi?
 
Binārās meklēšanas trūkums ir tāds, ka ievades masīvs ir jāsakārto, lai izlemtu, kurā pusē mērķa elements var atrasties. Tāpēc nešķirotiem masīviem pirms binārās meklēšanas izmantošanas masīvs ir jākārto.
 
8. Kad jāizmanto binārā meklēšana?
 
Binārā meklēšana ir jāizmanto, meklējot mērķa vērtību sakārtotā masīvā, īpaši, ja masīva lielums ir liels. Tas ir īpaši efektīvs lielām datu kopām salīdzinājumā ar lineārās meklēšanas algoritmiem.
 
9. Vai bināro meklēšanu var realizēt rekursīvi?
 
Jā, bināro meklēšanu var īstenot gan iteratīvi, gan rekursīvi. Rekursīvā ieviešana bieži noved pie kodolīgāka koda, taču tai var būt nedaudz lielāka pieskaitāmā vērtība rekursīvo steka telpas vai funkciju izsaukumu dēļ.
 
10. Vai binārā meklēšana vienmēr ir labākā izvēle, lai meklētu sakārtotā masīvā?
 
Lai gan binārā meklēšana ir ļoti efektīva, lai meklētu sakārtotos masīvos, var būt īpaši gadījumi, kad piemērotāki ir citi meklēšanas algoritmi, piemēram, strādājot ar nelielām datu kopām vai ja masīvs tiek bieži mainīts.
 
    Saistītie raksti:     
 
 Binārā meklēšana par atbilžu pamācību ar problēmām 
 Lineārā meklēšana pret bināro meklēšanu 
 Kā identificēt un atrisināt binārās meklēšanas problēmas?