logo

TechCodeview

Algorisme de cerca binària: implementació iterativa i recursiva

Cerca binària Algorisme és un algorisme de cerca utilitzat en una matriu ordenada per dividint repetidament l'interval de cerca per la meitat . La idea de la cerca binària és utilitzar la informació que la matriu està ordenada i reduir la complexitat del temps a O (log N).

Cerca binària és un algorisme de cerca utilitzat per trobar la posició d'un valor objectiu dins d'a ordenat matriu. Funciona dividint repetidament l'interval de cerca per la meitat fins que es trobi el valor objectiu o l'interval estigui buit. L'interval de cerca es redueix a la meitat comparant l'element objectiu amb el valor mitjà de l'espai de cerca.

java llarg a cadena

Per aplicar l'algorisme de cerca binària:



  • L'estructura de dades s'ha d'ordenar.
  • L'accés a qualsevol element de l'estructura de dades requereix un temps constant.

Algorisme de cerca binària:

En aquest algorisme,

  • Dividiu l'espai de cerca en dues meitats per trobar l'índex mitjà mig .

Trobar l'índex mitjà mig a l'algoritme de cerca binari

  • Compareu l'element central de l'espai de cerca amb la clau.
  • Si la clau es troba a l'element central, el procés finalitza.
  • Si la clau no es troba a l'element central, trieu quina meitat s'utilitzarà com a següent espai de cerca.
    • Si la clau és més petita que l'element central, el costat esquerre s'utilitzarà per a la propera cerca.
    • Si la clau és més gran que l'element central, el costat dret s'utilitzarà per a la cerca següent.
  • Aquest procés continua fins que es troba la clau o s'esgota l'espai de cerca total.

Com funciona l'algoritme de cerca binària?

Per entendre el funcionament de la cerca binària, tingueu en compte la il·lustració següent:

Considereu una matriu arr[] = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91} , i la objectiu = 23 .

Primer pas: Calcula el mitjà i compara l'element mitjà amb la clau. Si la clau és inferior a l'element central, moveu-vos cap a l'esquerra i, si és més gran que l'element central, moveu l'espai de cerca cap a la dreta.

  • La clau (és a dir, 23) és més gran que l'element central actual (és a dir, 16). L'espai de cerca es mou cap a la dreta.

Algorisme de cerca binari: compara la clau amb 16

  • La clau és inferior a la mitjana actual de 56. L'espai de cerca es mou cap a l'esquerra.

Algorisme de cerca binari: compara la clau amb 56

Segon pas: Si la clau coincideix amb el valor de l'element mitjà, l'element es troba i atura la cerca.

Algoritme de cerca binari: la clau coincideix amb el mitjà

Pràctica recomanada Cerca binària Prova-ho!

El Algorisme de cerca binària es pot implementar de les dues maneres següents

  • Algorisme de cerca binària iterativa
  • Algorisme de cerca binària recursiva

A continuació es mostren els pseudocodis dels enfocaments.

Algorisme de cerca binària iterativa:

Aquí fem servir un bucle while per continuar el procés de comparació de la clau i dividir l'espai de cerca en dues meitats.

Implementació de l'algoritme de cerca binària iterativa:

C++ 
// 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 
// 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 
// 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);  } }>
Python 
# 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# 
// 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);  } }>
Javascript 
// 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>= baix) { mig = baix + Math.floor((alt - baix) / 2);    // Si l'element està present al centre // mateix si (arr[mid] == x) retorna mig;    // Si l'element és més petit que mig, aleshores // només pot estar present al subbarray esquerre si (arr[mid]> x) alt = mig - 1;    // En cas contrari, l'element només pot estar present // al subbarrat dret else low = mid + 1;  } // Arribem aquí quan l'element // no està present a la matriu return -1; } arr =new Array (2, 3, 4, 10, 40);  x = 10;  n = arr.longitud;  resultat = binarySearch (arr, x);   (resultat == -1) ? console.log('L'element no està present a la matriu'): console.log ('L'element està present a l'índex ' + resultat);   // Aquest codi és aportat per simranarora5sos i rshuclubb>
PHP 
 // 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. ?>>
Sortida 
Element is present at index 3>

Complexitat temporal: O (log N)
Espai auxiliar: O(1)

Algorisme de cerca binària recursiva:

Creeu una funció recursiva i compareu la meitat de l'espai de cerca amb la clau. I en funció del resultat, retorneu l'índex on es troba la clau o truqueu la funció recursiva per al següent espai de cerca.

Implementació de l'algorisme de cerca binària recursiva:

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>= baix) { int mig = baix + (alt - baix) / 2;  // Si l'element està present al centre // mateix si (arr[mid] == x) retorna mig;  // Si l'element és més petit que mig, aleshores // només pot estar present al subbarray esquerre si (arr[mid]> x) retorna binarySearch(arr, low, mid - 1, x);  // En cas contrari, l'element només pot estar present // al subbarray dret return binarySearch(arr, mid + 1, high, x);  } } // Codi del controlador int main() { int arr[] = { 2, 3, 4, 10, 40 };  consulta int = 10;  int n = grandària de (arr) / grandària de (arr[0]);  int resultat = binarySearch (arr, 0, n - 1, consulta);  (resultat == -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>= baix) { int mig = baix + (alt - baix) / 2;  // Si l'element està present al centre // mateix si (arr[mid] == x) retorna mig;  // Si l'element és més petit que mig, aleshores // només pot estar present al subbarray esquerre si (arr[mid]> x) retorna binarySearch(arr, low, mid - 1, x);  // En cas contrari, l'element només pot estar present // al subbarray dret return binarySearch(arr, mid + 1, high, x);  } // Arribem aquí quan l'element // no està present a la matriu return -1; } // Codi del controlador int main() { int arr[] = { 2, 3, 4, 10, 40 };  int n = grandària de (arr) / grandària de (arr[0]);  int x = 10;  int resultat = binarySearch(arr, 0, n - 1, x);  (resultat == -1) ? printf('L'element no està present a la matriu'): printf('L'element està present a l'índex %d', resultat);  retorn 0; }>>>Java x) retorna binarySearch(arr, low, mid - 1, x);  // En cas contrari, l'element només pot estar present // al subbarray dret return binarySearch(arr, mid + 1, high, x);  } // Arribem aquí quan l'element no és present // a la matriu retorn -1;  } // Codi del controlador 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 resultat = ob.binarySearch(arr, 0, n - 1, x);  if (resultat == -1) System.out.println('L'element no està present a la matriu');  else System.out.println( 'L'element és present a l'índex ' + resultat);  } } /* Aquest codi és aportat per 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>= baix: mitjà = baix + (alt - baix) // 2 # Si l'element està present al centre si arr[mid] == x: retorn mig # Si l'element és més petit que el mitjà, llavors # només pot estar present al subbarrat esquerre elif arr[mid]> x: return binarySearch(arr, low, mid-1, x) # En cas contrari, l'element només pot estar present # al subbarrat dret else: return binarySearch(arr, mid + 1, high, x ) # L'element no és present a la matriu sinó: return -1 # Codi del controlador if __name__ == '__main__': arr = [2, 3, 4, 10, 40] x = 10 # Resultat de la trucada de funció = binarySearch( arr, 0, len(arr)-1, x) si resultat != -1: print('L'element és present a l'índex', resultat) sinó: print('L'element no està present a la matriu')>
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>= baix) { int mig = baix + (alt - baix) / 2;  // Si l'element està present al // mig mateix si (arr[mid] == x) retorna mig;  // Si l'element és més petit que mig, aleshores // només pot estar present al subbarray esquerre si (arr[mid]> x) retorna binarySearch(arr, low, mid - 1, x);  // En cas contrari, l'element només pot estar present // al subbarray dret return binarySearch(arr, mid + 1, high, x);  } // Arribem aquí quan l'element no és present // a la matriu retorn -1;  } // Codi del controlador public static void Main() { int[] arr = { 2, 3, 4, 10, 40 };  int n = arr.Longitud;  int x = 10;  int resultat = binarySearch(arr, 0, n - 1, x);  if (resultat == -1) Console.WriteLine( 'L'element no està present a arrau');  else Console.WriteLine('L'element és present a l'índex ' + resultat);  } } // Aquest codi és aportat per Sam007.>>>Javascript x) retorna binarySearch(arr, low, mid - 1, x);  // En cas contrari, l'element només pot estar present // al subbarray dret return binarySearch(arr, mid + 1, high, x);  } // Arribem aquí quan l'element // no està present a la matriu return -1; } sigui arr = [ 2, 3, 4, 10, 40 ]; siguem x = 10; let n = arr.length let result = binarySearch(arr, 0, n - 1, x); (resultat == -1) ? console.log('L'element no és present a la matriu'): console.log('L'element està present a l'índex ' +resultat);>>>PHP $x) return binarySearch($arr, $low, $mid - 1, $x ); // En cas contrari, l'element només pot // estar present al subbarray dret return binarySearch($arr, $mid + 1, $high, $x); } // Arribem aquí quan l'element // no està present a la matriu return -1; } // Codi del controlador $arr = array(2, 3, 4, 10, 40); $n = comptar ($arr); $x = 10; $resultat = binarySearch($arr, 0, $n - 1, $x); if(($resultat == -1)) echo 'L'element no està present a la matriu'; else echo 'L'element és present a l'índex ', $resultat; ?>>>
Sortida 
Element is present at index 3>
  • Complexitat temporal:
    • Millor cas: O(1)
    • Cas mitjà: O (log N)
    • El pitjor dels casos: O (log N)
  • Espai auxiliar: O(1), Si es considera la pila de trucades recursives, l'espai auxiliar serà O(logN).
  • La cerca binària es pot utilitzar com a element bàsic per a algorismes més complexos utilitzats en l'aprenentatge automàtic, com ara algorismes per entrenar xarxes neuronals o trobar els hiperparàmetres òptims per a un model.
  • Es pot utilitzar per a la cerca en gràfics per ordinador, com ara algorismes de traçat de raigs o mapes de textures.
  • Es pot utilitzar per cercar una base de dades.
  • La cerca binària és més ràpida que la cerca lineal, especialment per a matrius grans.
  • Més eficient que altres algorismes de cerca amb una complexitat temporal similar, com ara la cerca per interpolació o la cerca exponencial.
  • La cerca binària és molt adequada per cercar grans conjunts de dades que s'emmagatzemen a la memòria externa, com ara un disc dur o al núvol.
  • La matriu s'ha d'ordenar.
  • La cerca binària requereix que l'estructura de dades que s'està cercant s'emmagatzemi en ubicacions de memòria contigües.
  • La cerca binària requereix que els elements de la matriu siguin comparables, és a dir, que s'han de poder ordenar.

Preguntes freqüents (FAQ) a la cerca binària:

1. Què és la cerca binària?

La cerca binària és un algorisme eficient per trobar un valor objectiu dins d'una matriu ordenada. Funciona dividint repetidament l'interval de cerca per la meitat.

2. Com funciona la cerca binària?

La cerca binària compara el valor objectiu amb l'element central de la matriu. Si són iguals, la cerca té èxit. Si l'objectiu és inferior a l'element central, la cerca continua a la meitat inferior de la matriu. Si l'objectiu és més gran, la recerca continua a la meitat superior. Aquest procés es repeteix fins que es troba l'objectiu o l'interval de cerca està buit.

3. Quina és la complexitat temporal de la cerca binària?

La complexitat temporal de la cerca binària és O(log2n), on n és el nombre d'elements de la matriu. Això es deu al fet que la mida de l'interval de cerca es redueix a la meitat en cada pas.

4. Quins són els requisits previs per a la cerca binària?

La cerca binària requereix que la matriu estigui ordenada en ordre ascendent o descendent. Si la matriu no està ordenada, no podem utilitzar la cerca binària per cercar un element de la matriu.

5. Què passa si la matriu no s'ordena per a la cerca binària?

Si la matriu no està ordenada, la cerca binària pot retornar resultats incorrectes. Es basa en la naturalesa ordenada de la matriu per prendre decisions sobre quina meitat de la matriu cercar.

que gran és aquest monitor

6. Es pot aplicar la cerca binària a dades no numèriques?

Sí, la cerca binària es pot aplicar a dades no numèriques sempre que hi hagi un ordre definit per als elements. Per exemple, es pot utilitzar per cercar cadenes per ordre alfabètic.

7. Quins són alguns desavantatges habituals de la cerca binària?

El desavantatge de la cerca binària és que la matriu d'entrada s'ha d'ordenar per decidir en quina meitat de l'element objectiu pot estar. Per tant, per a les matrius no ordenades, hem d'ordenar la matriu abans d'aplicar la cerca binària.

8. Quan s'ha d'utilitzar la cerca binària?

La cerca binària s'ha d'utilitzar quan es cerca un valor objectiu en una matriu ordenada, especialment quan la mida de la matriu és gran. És especialment eficient per a grans conjunts de dades en comparació amb els algorismes de cerca lineal.

9. Es pot implementar la cerca binària de forma recursiva?

Sí, la cerca binària es pot implementar tant de manera iterativa com recursiva. La implementació recursiva sovint condueix a un codi més concís, però pot tenir una sobrecàrrega una mica més alta a causa de l'espai recursiu de la pila o de les trucades de funcions.

10. La cerca binària és sempre la millor opció per cercar en una matriu ordenada?

Tot i que la cerca binària és molt eficient per cercar en matrius ordenades, hi pot haver casos específics en què altres algorismes de cerca siguin més adequats, com quan es tracten conjunts de dades petits o quan la matriu es modifica amb freqüència.

Articles relacionats:

  • Tutorial de cerca binària a respostes amb problemes
  • Cerca lineal vs cerca binària
  • Com identificar i resoldre problemes de cerca binària?