Maison >Java >javaDidacticiel >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.
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 :
Plongeons dans les exemples de code.
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
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.");
}
}
}
Dans les deux implémentations :
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.
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
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.");
}
}
}
Dans chaque appel récursif :
La recherche binaire est idéale lorsque :
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.
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.
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!