Maîtriser la recherche binaire en JavaScript et Java : un guide étape par étape

La recherche binaire est un algorithme fondamental que tout développeur doit comprendre, offrant un moyen très efficace de rechercher des éléments dans un tableau trié. Cet algorithme s'appuie sur une approche « diviser pour mieux régner », lui permettant de diviser par deux l'espace de recherche à chaque étape. Dans cet article, nous explorerons la recherche binaire en JavaScript et Java, couvrant les implémentations itératives et récursives.

Qu’est-ce que la recherche binaire ?

La recherche binaire est un algorithme conçu pour trouver la position d'une valeur cible dans un tableau trié. En tirant parti de la nature triée du tableau, la recherche binaire réduit efficacement l'espace de recherche, atteignant une complexité temporelle de O (log n). C'est beaucoup plus rapide qu'une recherche linéaire dans de grands ensembles de données.

Voici un aperçu de haut niveau :

1. Commencez avec deux pointeurs, startIndex et endIndex, représentant la plage de recherche actuelle.
2. Calculez l'index intermédiaire (midIndex) entre startIndex et endIndex.
3. Comparez l'élément du milieu à la cible :
   • S'il correspond à la cible, renvoyez l'index.
   • Si l'élément du milieu est supérieur à la cible, la cible doit être dans la moitié gauche, alors ajustez endIndex.
   • Si l'élément du milieu est inférieur à la cible, la cible doit être dans la moitié droite, alors ajustez startIndex.
4. Répétez le processus jusqu'à ce que la cible soit trouvée ou que startIndex dépasse endIndex, indiquant que la cible n'est pas dans le tableau.

Plongeons dans les exemples de code.

---

Recherche binaire itérative en JavaScript et Java

Pour ceux d'entre vous qui aiment une boucle.

Implémentation JavaScript

En JavaScript, l'approche itérative utilise une boucle pour effectuer une recherche binaire. Voici à quoi cela ressemble :

const binarySearch = (arr, target) => {
  let startIndex = 0;
  let endIndex = arr.length - 1;

  while (startIndex <= endIndex) {
    let midIndex = Math.floor((startIndex + endIndex) / 2);

    if (arr[midIndex] === target) {
      return midIndex; // Target found
    } else if (arr[midIndex] < target) {
      startIndex = midIndex + 1; // Search in the right half
    } else {
      endIndex = midIndex - 1; // Search in the left half
    }
  }
  return -1; // Target not found
};

let nums = [-1, 0, 3, 5, 9, 12];
console.log(binarySearch(nums, 9)); // Output: 4
console.log(binarySearch(nums, 2)); // Output: -1

Implémentation Java

En Java, l'implémentation itérative est assez similaire, avec des ajustements pour la syntaxe Java :

public class BinarySearchExample {

    public static int binarySearch(int[] arr, int target) {
        int startIndex = 0;
        int endIndex = arr.length - 1;

        while (startIndex <= endIndex) {
            int midIndex = (startIndex + endIndex) / 2;

            if (arr[midIndex] == target) {
                return midIndex; // Target found
            } else if (arr[midIndex] < target) {
                startIndex = midIndex + 1; // Search in the right half
            } else {
                endIndex = midIndex - 1; // Search in the left half
            }
        }
        return -1; // Target not found
    }

    public static void main(String[] args) {
        int[] nums = {-1, 0, 3, 5, 9, 12};
        int target = 9;

        int result = binarySearch(nums, target);
        if (result != -1) {
            System.out.println("Element found at index: " + result);
        } else {
            System.out.println("Element not found in the array.");
        }
    }
}

Explication

Dans les deux implémentations :

• Nous définissons startIndex et endIndex respectivement au début et à la fin du tableau.
• Chaque itération trouve l'index du milieu, midIndex, et compare arr[midIndex] à la cible.
  • Si arr[midIndex] est égal à la cible, nous renvoyons midIndex.
  • Si arr[midIndex] est inférieur à la cible, nous déplaçons startIndex vers midIndex 1, limitant la recherche à la moitié droite.
  • Si arr[midIndex] est supérieur à target, nous déplaçons endIndex vers midIndex - 1, limitant la recherche à la moitié gauche.
• La boucle se termine si startIndex dépasse endIndex, ce qui signifie que la cible n'est pas dans le tableau.

---

Recherche binaire récursive en JavaScript et Java

Pour l'approche récursive, nous définissons la fonction pour qu'elle s'appelle avec des indices mis à jour jusqu'à ce que la cible soit trouvée ou que la plage de recherche soit vide.

Pour ceux d'entre vous qui aiment les débuts.

Implémentation JavaScript

En JavaScript, voici une implémentation de recherche binaire récursive :

const binarySearch = (arr, target) => {
  let startIndex = 0;
  let endIndex = arr.length - 1;

  while (startIndex <= endIndex) {
    let midIndex = Math.floor((startIndex + endIndex) / 2);

    if (arr[midIndex] === target) {
      return midIndex; // Target found
    } else if (arr[midIndex] < target) {
      startIndex = midIndex + 1; // Search in the right half
    } else {
      endIndex = midIndex - 1; // Search in the left half
    }
  }
  return -1; // Target not found
};

let nums = [-1, 0, 3, 5, 9, 12];
console.log(binarySearch(nums, 9)); // Output: 4
console.log(binarySearch(nums, 2)); // Output: -1

Implémentation Java

En Java, une recherche binaire récursive similaire peut être implémentée comme suit :

public class BinarySearchExample {

    public static int binarySearch(int[] arr, int target) {
        int startIndex = 0;
        int endIndex = arr.length - 1;

        while (startIndex <= endIndex) {
            int midIndex = (startIndex + endIndex) / 2;

            if (arr[midIndex] == target) {
                return midIndex; // Target found
            } else if (arr[midIndex] < target) {
                startIndex = midIndex + 1; // Search in the right half
            } else {
                endIndex = midIndex - 1; // Search in the left half
            }
        }
        return -1; // Target not found
    }

    public static void main(String[] args) {
        int[] nums = {-1, 0, 3, 5, 9, 12};
        int target = 9;

        int result = binarySearch(nums, target);
        if (result != -1) {
            System.out.println("Element found at index: " + result);
        } else {
            System.out.println("Element not found in the array.");
        }
    }
}

Comment fonctionne la version récursive

Dans chaque appel récursif :

• L'indice du milieu, midIndex, est calculé.
• Si arr[midIndex] correspond à la cible, il renvoie l'index.
• Si arr[midIndex] est supérieur à la cible, la recherche continue dans la moitié gauche (endIndex devient midIndex - 1).
• Si arr[midIndex] est inférieur à la cible, la recherche continue dans la moitié droite (startIndex devient midIndex 1).
• Le cas de base if (startIndex > endIndex) garantit que la récursion s'arrête si la cible n'est pas trouvée.

  ---

  Analyse de complexité

  • Complexité temporelle : les versions itératives et récursives ont une complexité temporelle de O(log n), car chaque étape divise par deux l'espace de recherche.
  • Complexité spatiale : L'approche itérative est O(1) pour l'espace, tandis que l'approche récursive a une complexité spatiale de O(log n) en raison de la pile d'appels.

  Quand utiliser la recherche binaire

  La recherche binaire est idéale lorsque :

  • Le tableau est trié : La recherche binaire ne fonctionne que sur les tableaux triés.
  • L'efficacité est essentielle : sa complexité temporelle O(log n) est très efficace pour les grands ensembles de données.

  Si le tableau n'est pas trié, envisagez de le trier d'abord (à un coût O(n log n)) ou d'utiliser une recherche linéaire si l'ensemble de données est petit.

  ---

  Conclusion

  La recherche binaire est un algorithme polyvalent et efficace pour localiser des éléments dans des tableaux triés. Que vous choisissiez l'approche itérative ou récursive, comprendre la recherche binaire est précieux pour améliorer les performances de vos applications. Essayez les deux implémentations en JavaScript et Java pour avoir une idée de leur fonctionnement et voir laquelle convient le mieux à votre cas d'utilisation spécifique.

  ---

  ? Référence

  • Recherche binaire
  • Algorithmes de Grookking
  • Notation Big O

  ? Parle moi

  • LinkedIn
  • Github
  • Portefeuille

  Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!