Recherche binaire en Javascript
J'essaie d'implémenter un algorithme de recherche binaire en JavaScript. Les choses semblent aller bien, mais mes déclarations de retour semblent être non définies? Quelqu'un peut-il dire ce qui ne va pas ici?
Fiddle: http://jsfiddle.net/2mBdL/
Merci.
var a = [
1,
2,
4,
6,
1,
100,
0,
10000,
3
];
a.sort(function (a, b) {
return a - b;
});
console.log('a,', a);
function binarySearch(arr, i) {
var mid = Math.floor(arr.length / 2);
console.log(arr[mid], i);
if (arr[mid] === i) {
console.log('match', arr[mid], i);
return arr[mid];
} else if (arr[mid] < i && arr.length > 1) {
console.log('mid lower', arr[mid], i);
binarySearch(arr.splice(mid, Number.MAX_VALUE), i);
} else if (arr[mid] > i && arr.length > 1) {
console.log('mid higher', arr[mid], i);
binarySearch(arr.splice(0, mid), i);
} else {
console.log('not here', i);
return -1;
}
}
var result = binarySearch(a, 100);
console.log(result);
Vous ne renvoyez pas explicitement les appels internes récursifs (c'est-à-dire return binarySearch()). La pile d'appels se déplie alors sans valeur de retour. Mettez à jour votre code comme suit:
// ...
if (arr[mid] === i) {
console.log('match', arr[mid], i);
return arr[mid];
} else if (arr[mid] < i && arr.length > 1) {
console.log('mid lower', arr[mid], i);
return binarySearch(arr.splice(mid, Number.MAX_VALUE), i);
} else if (arr[mid] > i && arr.length > 1) {
console.log('mid higher', arr[mid], i);
return binarySearch(arr.splice(0, mid), i);
} else {
// ...
Voir un violon de travail
Il est utile d'écrire une fonction de recherche de telle sorte qu'elle renvoie une valeur négative indiquant le point d'insertion du nouvel élément si l'élément n'est pas trouvé. De plus, utiliser la récursivité dans une recherche binaire est excessif et inutile. Enfin, il est recommandé de générer un algorithme de recherche générique en fournissant une fonction de comparaison en tant que paramètre. Ci-dessous, la mise en œuvre.
function binarySearch(ar, el, compare_fn) {
var m = 0;
var n = ar.length - 1;
while (m <= n) {
var k = (n + m) >> 1;
var cmp = compare_fn(el, ar[k]);
if (cmp > 0) {
m = k + 1;
} else if(cmp < 0) {
n = k - 1;
} else {
return k;
}
}
return -m - 1;
}
Ce code avec des commentaires et un test unitaire ici .
Il existe de nombreuses solutions pratiques à cette question, mais reviennent toutes tôt une fois qu'elles ont trouvé une correspondance. Bien que cela puisse avoir un léger effet positif sur les performances, il est négligeable en raison de la nature logarithmique de la recherche binaire et peut même nuire aux performances si la fonction de comparaison est coûteuse à calculer.
Qui plus est, cela empêche une application très utile de l'algorithme de recherche binaire: rechercher une plage d'éléments correspondants, également appelée recherche de inférieur ou borne supérieure.
L'implémentation suivante renvoie un index 0 ≤ i ≤ array.length tel que le prédicat donné soit false pour array[i - 1] et true pour array[i]. Si le prédicat est false partout, array.length est renvoyé.
/**
* Return 0 <= i <= array.length such that !pred(array[i - 1]) && pred(array[i]).
*/
function binarySearch(array, pred) {
let lo = -1, hi = array.length;
while (1 + lo < hi) {
const mi = lo + ((hi - lo) >> 1);
if (pred(array[mi])) {
hi = mi;
} else {
lo = mi;
}
}
return hi;
}Supposons, par souci d'argument, que pred(array[-1]) === false et pred(array[array.length]) === true (bien que, bien entendu, le prédicat ne soit jamais évalué à ces points). La boucle conserve l'invariant !pred(array[lo]) && pred(array[hi]). L'algorithme se termine lorsque 1 + lo === hi, ce qui implique !pred(array[hi - 1]) && pred(array[hi]), la postcondition souhaitée.
Si un tableau est sort()ed par rapport à une fonction de comparaison compare, la fonction renvoie le le plus petit} _ insérer la position d'un item lorsqu'il est appelé
binarySearch(array, j => 0 <= compare(item, j));
Un insert position est un index auquel un élément serait trouvé s'il existait dans le tableau.
Il est facile d'implémenter inférieur et limite supérieure pour un tableau en ordre naturel, comme suit.
/**
* Return i such that array[i - 1] < item <= array[i].
*/
function lowerBound(array, item) {
return binarySearch(array, j => item <= j);
}
/**
* Return i such that array[i - 1] <= item < array[i].
*/
function upperBound(array, item) {
return binarySearch(array, j => item < j);
}Bien entendu, cela est particulièrement utile lorsque le tableau peut contenir plusieurs éléments qui se comparent de manière identique, par exemple lorsque les éléments contiennent des données supplémentaires qui ne font pas partie des critères de tri.
Voici la fonction de recherche binaire, vous pouvez vérifier
function bsearch (Arr,value){
var low = 0 , high = Arr.length -1 ,mid ;
while (low <= high){
mid = Math.floor((low+high)/2);
if(Arr[mid]==value) return mid ;
else if (Arr[mid]<value) low = mid+1;
else high = mid-1;
}
return -1 ;
}
C'est ma solution!
// perform a binarysearch to find the position in the array
function binarySearch(searchElement, searchArray) {
'use strict';
var stop = searchArray.length;
var last, p = 0,
delta = 0;
do {
last = p;
if (searchArray[p] > searchElement) {
stop = p + 1;
p -= delta;
} else if (searchArray[p] === searchElement) {
// FOUND A MATCH!
return p;
}
delta = Math.floor((stop - p) / 2);
p += delta; //if delta = 0, p is not modified and loop exits
}while (last !== p);
return -1; //nothing found
};
Recherche binaire ES6
// bottom-up
function binarySearch (arr, val) {
let start = 0;
let end = arr.length - 1;
while (start <= end) {
let mid = Math.floor((start + end) / 2);
if (arr[mid] === val) {
return mid;
}
if (val < arr[mid]) {
end = mid - 1;
} else {
start = mid + 1;
}
}
return -1;
}
une approche différente:
// recursive
function binarySearch(arr, val, start = 0, end = arr.length - 1) {
const mid = Math.floor((start + end) / 2);
if (val === arr[mid]) {
return mid;
}
if (start >= end) {
return -1;
}
return val < arr[mid]
? binarySearch(arr, val, start, mid - 1)
: binarySearch(arr, val, mid + 1, end);
}
[Excuses à Joki: ma réponse initiale était fondamentalement un clone allégé de sa solution. Pour corriger mes torts, j'ai déchiré ma réponse initiale et inventé une nouvelle solution originale, vue ci-dessous ????]
Tu veux de la vitesse? Lis ça. (S'il vous plaît.)
Les recherches binaires mises en œuvre correctement (sans modifier le tableau, faire des copies du tableau ou d’autres absurdités) ont une complexité moyenne autour de O (k * log2(n)) (où k est constant). Supposons que vous avez un tableau de 1024 éléments et que la constante k est 1 dans ce cas. Avec une recherche linéaire, la complexité moyenne serait de O (k * n/2) = O (1 * 1024/2) = O (512) . Avec une recherche binaire, vous auriez une complexité de O (k * log2(n)) = O (1 * log2(1024)) = O (1 * 10) = O (10) . Supposons maintenant que l'algorithme de recherche linéaire soit deux fois plus rapide et l'algorithme de recherche binaire deux fois plus rapide: maintenant, k est égal à 0,5; la complexité de la recherche linéaire diminue à O(256) (gain de 256 points de performance), alors que la recherche binaire décroît O(5) (gain de seulement 5 points de performance). Ce gain minimal de l'optimisation de la méthode de recherche binaire est dû au fait que la méthode de recherche binaire est déjà si rapide. Par conséquent, toute personne sensée devrait être plus encline à optimiser le reste de son programme avant d’essayer d’optimiser son algorithme de recherche binaire. Cependant, je ne suis pas une personne sensée; ainsi, j'ai optimisé la fonction de recherche binaire à (ce que je crois être) la limite absolue (en javascript).
Pour commencer les maxima de performance, examinons d’abord la fonction initiale avec laquelle j’ai commencé. Cette fonction peut être beaucoup plus lente que celles présentées plus bas dans la page, mais elle devrait être plus facile à comprendre afin que vous ne soyez pas complètement perdu plus tard.
const sArr = [0,4,5,6,9,13,14,21,27,44];
document.write(slowestBS(sArr, 14)); // don't use document.write in production
function slowestBS(array, searchedValue, ARG_start, ARG_len){
// Range of [start, start+len): only start is inclusive. It works
// similarly to "...".substr(start, len).indexOf(sValue)
// `void 0` is shorthand for `undefined`
var start = ARG_start |0;
var len = (ARG_len === void 0 ? (array.length|0)-start : ARG_len) | 0;
len = len - 1 |0;
for (let i=0x80000000; i; i >>>= 1) {
if (len & i) {
const withoutCurBit = len & ~(i-1);
if (array[start + withoutCurBit] > searchedValue) {
len = withoutCurBit - 1 |0;
}
}
}
if (array[start+len] !== searchedValue) {
// remove this if-statement to return the next closest
// element going downwards from the searched-for value
// OR 0 if the value is less than all values in the
// array
return (-1 - start |0) - len |0;
}
return start + len |0;
}La valeur de retour de la fonction ci-dessus est la suivante.
- Si la valeur a été trouvée, elle renvoie alors l'index de la valeur.
- Si la valeur n'a pas été trouvée, alors il retourne
-1 - nearestIndexoù index_plus proche est l'index trouvé, qui est le nombre le plus proche <= index et est plafonné à 0. - Si le tableau n'est pas trié dans la plage spécifiée, il renverra un nombre sans signification.
Pour commencer les optimisations, retirons d’abord cette si-branche interne embêtante.
const sArr = [0,4,5,6,9,13,14,21,27,44];
document.write(compactBS(sArr, 44)); // don't use document.write in production
function compactBS(array, searchedValue, ARG_start, ARG_len){
// `void 0` is shorthand for `undefined`
var start = ARG_start === void 0 ? 0 : ARG_start |0;
var len = (ARG_len === void 0 ? (array.length|0) - start : ARG_len) |0;
len = len - 1 | 0;
for (let i=0x80000000; i; i >>>= 1) {
if (len & i) {
const noCBit = len & ~(i-1);
// noCBits now contains all the bits in len that are
// greater than the present value of i.
len ^= (
(len ^ (noCBit-1)) &
((array[start+noCBit] <= searchedValue |0) - 1 >>>0)
); // works based on the logic that `(x^y)^x === y` is always true
}
}
if (array[start+len] !== searchedValue) {
// remove this if-statement to return the next closest
// element going downwards from the searched-for value
// OR 0 if the value is less than all values in the
// array
return (-1 - start |0) - len |0;
}
return start + len |0;
}Et maintenant, déroulez-le, précalculez-le, rendez-le rapide, gentil et bon, juste comme ça:
const sArr = [0,4,5,6,9,13,14,21,27,44];
document.write(goodBinarySearch(sArr, 5)); // don't use document.write in
// production
function goodBinarySearch(array, sValue, ARG_start, ARG_len){
// Range of [start, start+len): only start is inclusive. It works
// similarly to "...".substr(start, len).indexOf(sValue)
// `void 0` is shorthand for `undefined`
var start = (ARG_start === void 0 ? 0 : ARG_start) | 0;
var len = (ARG_len === void 0 ? (array.length|0) - start : ARG_len) |0;
len = len - 1 |0;
if (len & 0x80000000) {
const nCB = len & 0x80000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x40000000) {
const nCB = len & 0xc0000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x20000000) {
const nCB = len & 0xe0000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x10000000) {
const nCB = len & 0xf0000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x8000000) {
const nCB = len & 0xf8000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x4000000) {
const nCB = len & 0xfc000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x2000000) {
const nCB = len & 0xfe000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x1000000) {
const nCB = len & 0xff000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x800000) {
const nCB = len & 0xff800000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x400000) {
const nCB = len & 0xffc00000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x200000) {
const nCB = len & 0xffe00000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x100000) {
const nCB = len & 0xfff00000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x80000) {
const nCB = len & 0xfff80000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x40000) {
const nCB = len & 0xfffc0000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x20000) {
const nCB = len & 0xfffe0000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x10000) {
const nCB = len & 0xffff0000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x8000) {
const nCB = len & 0xffff8000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x4000) {
const nCB = len & 0xffffc000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x2000) {
const nCB = len & 0xffffe000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x1000) {
const nCB = len & 0xfffff000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x800) {
const nCB = len & 0xfffff800;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x400) {
const nCB = len & 0xfffffc00;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x200) {
const nCB = len & 0xfffffe00;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x100) {
const nCB = len & 0xffffff00;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x80) {
const nCB = len & 0xffffff80;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x40) {
const nCB = len & 0xffffffc0;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x20) {
const nCB = len & 0xffffffe0;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x10) {
const nCB = len & 0xfffffff0;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x8) {
const nCB = len & 0xfffffff8;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x4) {
const nCB = len & 0xfffffffc;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x2) {
const nCB = len & 0xfffffffe;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x1) {
const nCB = len & 0xffffffff;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (array[start+len|0] !== sValue) {
// remove this if-statement to return the next closest
// element going downwards from the searched-for value
// OR 0 if the value is less than all values in the
// array
return (-1 - start |0) - len |0;
}
return start + len |0;
}Mais attendez ... chuchotons à la veille de performances encore meilleures. Probablement, vous appelez la recherche binaire dans une boucle serrée. Dans un tel cas, nous pouvons précalculer la première valeur qui sera effectivement traitée et y accéder directement avec nos performances, notre seigneur et sauveur: l’instruction integer switch. TOUTEFOIS, lors de l'utilisation de cette option, vous devez vous assurer de ne jamais réutiliser la fonction rapide générée après la modification de la longueur du tableau, car seule une partie de celui-ci sera recherchée.
const clz32 = Math.clz32 || (function(log, LN2){
return function(x) {
return 31 - log(x >>> 0) / LN2 | 0; // the "| 0" acts like math.floor
};
})(Math.log, Math.LN2);
const sArr = [0,4,5,6,9,13,14,21,27,44];
const compFunc = fastestBS(sArr);
for (let x of sArr) // don't use for-of in production
// this statement is esoteric: a traditional for loop is always faster
// than for-of, and even more so faster when you need the index!
document.write(x+" is at "+compFunc(x)+"<br/>"); // don't use document.write
// in production
function fastestBS(array, ARG_start, ARG_initLen){
// Range of [start, start+len): only start is inclusive. It works
// similarly to "...".substr(start, len).indexOf(sValue)
// `void 0` is shorthand for `undefined`
var start = ARG_start === void 0 ? 0 : ARG_start |0;
var initLen = (ARG_initLen===void 0 ? (array.length|0)-start : ARG_initLen) |0;
initLen = initLen - 1 |0;
const compGoto = clz32(initLen) & 31;
return function(sValue) {
var len = initLen | 0;
switch (compGoto) {
case 0:
if (len & 0x80000000) {
const nCB = len & 0x80000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 1:
if (len & 0x40000000) {
const nCB = len & 0xc0000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 2:
if (len & 0x20000000) {
const nCB = len & 0xe0000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 3:
if (len & 0x10000000) {
const nCB = len & 0xf0000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 4:
if (len & 0x8000000) {
const nCB = len & 0xf8000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 5:
if (len & 0x4000000) {
const nCB = len & 0xfc000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 6:
if (len & 0x2000000) {
const nCB = len & 0xfe000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 7:
if (len & 0x1000000) {
const nCB = len & 0xff000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 8:
if (len & 0x800000) {
const nCB = len & 0xff800000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 9:
if (len & 0x400000) {
const nCB = len & 0xffc00000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 10:
if (len & 0x200000) {
const nCB = len & 0xffe00000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 11:
if (len & 0x100000) {
const nCB = len & 0xfff00000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 12:
if (len & 0x80000) {
const nCB = len & 0xfff80000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 13:
if (len & 0x40000) {
const nCB = len & 0xfffc0000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 14:
if (len & 0x20000) {
const nCB = len & 0xfffe0000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 15:
if (len & 0x10000) {
const nCB = len & 0xffff0000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 16:
if (len & 0x8000) {
const nCB = len & 0xffff8000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 17:
if (len & 0x4000) {
const nCB = len & 0xffffc000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 18:
if (len & 0x2000) {
const nCB = len & 0xffffe000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 19:
if (len & 0x1000) {
const nCB = len & 0xfffff000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 20:
if (len & 0x800) {
const nCB = len & 0xfffff800;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 21:
if (len & 0x400) {
const nCB = len & 0xfffffc00;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 22:
if (len & 0x200) {
const nCB = len & 0xfffffe00;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 23:
if (len & 0x100) {
const nCB = len & 0xffffff00;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 24:
if (len & 0x80) {
const nCB = len & 0xffffff80;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 25:
if (len & 0x40) {
const nCB = len & 0xffffffc0;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 26:
if (len & 0x20) {
const nCB = len & 0xffffffe0;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 27:
if (len & 0x10) {
const nCB = len & 0xfffffff0;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 28:
if (len & 0x8) {
const nCB = len & 0xfffffff8;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 29:
if (len & 0x4) {
const nCB = len & 0xfffffffc;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 30:
if (len & 0x2) {
const nCB = len & 0xfffffffe;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
case 31:
if (len & 0x1) {
const nCB = len & 0xffffffff;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
}
if (array[start+len|0] !== sValue) {
// remove this if-statement to return the next closest
// element going downwards from the searched-for value
// OR 0 if the value is less than all values in the
// array
return (-1 - start |0) - len |0;
}
return start + len |0;
};
}Puisque
Démo:
(function(document){"use strict";
var textarea = document.getElementById('inputbox'),
searchinput = document.getElementById('search'),
searchStart = document.getElementById('start'),
searchedLength = document.getElementById('length'),
resultbox = document.getElementById('result'),
timeoutID = -1;
function doUpdate(){
try {
var txt = textarea.value.replace(/\s*\[|\]\s*/g, '').split(',');
var arr = JSON.parse(textarea.value);
var searchval = JSON.parse(searchinput.value);
var textmtchs = textarea.value.match(/\s*\[|\]\s*/g);
var start = searchStart.value || void 0;
var sub = searchedLength.value || void 0;
txt = refSort(txt, arr);
textarea.value = textmtchs[0] +
txt.join(',') +
textmtchs[textmtchs.length-1];
arr = JSON.parse(textarea.value);
resultbox.value = goodBinarySearch(arr, searchval, start, sub);
} catch(e) {
resultbox.value = 'Error';
}
}
textarea.oninput = searchinput.oninput =
searchStart.oninput = searchedLength.oninput =
textarea.onkeyup = searchinput.onkeyup =
searchStart.onkeyup = searchedLength.onkeyup =
textarea.onchange = searchinput.onchange =
searchStart.onchange = searchedLength.onchange = function(e){
clearTimeout( timeoutID );
timeoutID = setTimeout(doUpdate, e.target === textarea ? 384 : 125);
}
function refSort(targetData, refData) {
var indices = Object.keys(refData);
indices.sort(function(indexA, indexB) {
if (refData[indexA] < refData[indexB]) return -1;
if (refData[indexA] > refData[indexB]) return 1;
return 0;
});
return indices.map(function(i){ return targetData[i] })
}
function goodBinarySearch(array, sValue, ARG_start, ARG_len){
// Range of [start, start+len): only start is inclusive. It works
// similarly to "...".substr(start, len).indexOf(sValue)
// `void 0` is shorthand for `undefined`
var start = (ARG_start === void 0 ? 0 : ARG_start) | 0;
var len = (ARG_len === void 0 ? (array.length|0) - start : ARG_len) |0;
len = len - 1 |0;
if (len & 0x80000000) {
const nCB = len & 0x80000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x40000000) {
const nCB = len & 0xc0000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x20000000) {
const nCB = len & 0xe0000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x10000000) {
const nCB = len & 0xf0000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x8000000) {
const nCB = len & 0xf8000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x4000000) {
const nCB = len & 0xfc000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x2000000) {
const nCB = len & 0xfe000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x1000000) {
const nCB = len & 0xff000000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x800000) {
const nCB = len & 0xff800000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x400000) {
const nCB = len & 0xffc00000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x200000) {
const nCB = len & 0xffe00000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x100000) {
const nCB = len & 0xfff00000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x80000) {
const nCB = len & 0xfff80000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x40000) {
const nCB = len & 0xfffc0000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x20000) {
const nCB = len & 0xfffe0000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x10000) {
const nCB = len & 0xffff0000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x8000) {
const nCB = len & 0xffff8000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x4000) {
const nCB = len & 0xffffc000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x2000) {
const nCB = len & 0xffffe000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x1000) {
const nCB = len & 0xfffff000;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x800) {
const nCB = len & 0xfffff800;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x400) {
const nCB = len & 0xfffffc00;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x200) {
const nCB = len & 0xfffffe00;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x100) {
const nCB = len & 0xffffff00;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x80) {
const nCB = len & 0xffffff80;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x40) {
const nCB = len & 0xffffffc0;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x20) {
const nCB = len & 0xffffffe0;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x10) {
const nCB = len & 0xfffffff0;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x8) {
const nCB = len & 0xfffffff8;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x4) {
const nCB = len & 0xfffffffc;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x2) {
const nCB = len & 0xfffffffe;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (len & 0x1) {
const nCB = len & 0xffffffff;
len ^= (len ^ (nCB-1)) & ((array[start+nCB|0] <= sValue |0) - 1 >>>0);
}
if (array[start+len|0] !== sValue) {
// remove this if-statement to return the next closest
// element going downwards from the searched-for value
// OR 0 if the value is less than all values in the
// array
return (-1 - start |0) - len |0;
}
return start + len |0;
}
})(document);<h3 style="margin:.125em;width:100%;text-align:center">The Array (Must Be A Valid JSON Array)</h3>
<textarea placeholder="[-24, -12, 0, 0, 9, 16, 18, 64, 80]" type="text" rows=6 style="width:calc(100% - .5em);display:block" id="inputbox">[-24, -12, 0, 0, 9, 16, 18, 64, 80]</textarea>
<table style="table-layout:fixed;font-size:1.2em" width="100%"><tbody>
<tr>
<td colspan="3">Search Value: <input type="text" id="search" value="-12" style="width:8em;text-align:center;float:right" /></td>
<td></td>
<td colspan="3">Resulting Index: <input type="text" id="result" value="1" style="width:8em;text-align:center;float:right" readonly="" />
</tr>
<tr>
<td colspan="3">Start Index: <input type="text" id="start" value="" placeholder="(0)" style="width:8em;text-align:center;float:right" /></td>
<td></td>
<td colspan="3">Searched Length: <input type="text" id="length" value="" placeholder="(array length)" style="width:8em;text-align:center;float:right" />
</tr>
</tbody></table>Vous pouvez également utiliser un tableau de chaînes (entouré de guillemets) dans la démo, et cela devrait fonctionner correctement. Pour rechercher une chaîne, vous devez mettre des guillemets autour de la valeur de recherche.
Je souhaite ajouter ma fonction de recherche searchArray binary, ainsi que les fonctions utilitaires d’outil insertSortedArray et removeSortedArray à la liste des réponses, car je pense que c’est propre, il est d’utilisation globale et je pense que sa vitesse est optimale.
Je pense que l'option ci-dessous est simple à mettre en œuvre la recherche binaire dans JS.
arr = [1,2,3,4,5];
searchTerm=2;
function binarySearchInJS(start,end)
{
isFound=false;
if(end > start)
{
//console.log(start+"\t"+end)
mid = (end+start)/2;
mid = Math.floor(mid)
if(searchTerm==arr[mid])
{
isFound = true;
}
else
{
if(searchTerm < arr[mid])
{
binarySearchInJS(start,mid);
}
if(searchTerm > arr[mid])
{
binarySearchInJS(mid+1,end);
}
}
}
if(isFound)
{
return "Success";
}
else{
return "Not Found";
}
}
pour l'utiliser, il suffit de copier-coller tel quel, afin d'utiliser des variables locales pour plus de rapidité. et modifiez la valeur recherchée comme si vous cherchiez dans des sous-objets ou des tableaux:
if (array[mid][0] < value[0]) low = mid + 1;
if (array[mid].val < value.val) low = mid + 1;
pour des résultats plus rapides, utilisez des tableaux ou des tableaux de tableaux ou des tableaux parallèles, copiez les tableaux recherchés dans des variables locales. variables non locales ou chaque fois que vous faites obj.quelque chose il ralentit.
voici la version la plus rapide:
let array=[3,4,5,6]
let value=5; //searched value
let mid, low = 0,high = array.length;
while (low < high) {
mid = low + high >>> 1; // fast divide by 2 and round down
if (array[mid] < value) low = mid + 1;
else high = mid;
}
//if (array[mid] != value) mid=-1;// this might not be required if you look for place to insert new value
mid;// contains the found value position or if not found one before where it would be if it was found
la recherche binaire fonctionne comme ceci:
| . | // find middle
//option 1:
| . v | // if value on right, middle is top
| . | // so then it is like this
//option 2:
| v . | // if value on left, middle is bottom
| . | // so then it is like this
//more loops of option 2 until not found
| . | // next time it will be like this
|. | // next time it will be like this
. // next time it will be like this
cette implémentation va au fond si elle n’est pas trouvée. il pourrait être trouvé ou pas trouvé toujours . il retourne l'index ci-dessous ou est égal à la valeur recherchée . donc vous devez vérifier si elle est égale. pour valider si la valeur existe ou s'il ne s'agit que d'un résultat ci-dessous. si vous cherchez un endroit pour insérer un ordre afin de mettre à cet endroit, pas besoin de vérifier si est égal
Vous devez également rechercher le cas Edge "valeur non trouvée" et en faire votre première condition de base, suivie d'une recherche réussie. Par conséquent, vous n'avez pas besoin de vérifier la longueur du tableau> 1 lorsque vous passez à travers le tableau. Enfin, puisque vous ne renvoyez pas le tableau, pourquoi ne pas utiliser la méthode Array.prototype.slice?
var binarySearch = function(arr, val) {
var half = Math.floor(arr.length / 2);
if (arr.length === 0) {
return -1;
}
else if (arr[half] === val) {
console.log("val: ", val, "arr[half]: ", arr[half]);
return val;
}
else if (val > arr[half]) {
console.log("val: ", val, "arr[half]: ", arr[half]);
return binarySearch(arr.slice(half, arr.length), val);
}
else {
console.log("val: ", val, "arr[half]: ", arr[half]);
return binarySearch(arr.slice(0, half), val);
}
}
var arr = [1, 5, 20, 58, 76, 8, 19, 41].sort(function(a, b) { return a - b });
console.log("Sorted array: " + arr);
console.log(binarySearch(arr, 76));
console.log(binarySearch(arr, 19));
console.log(binarySearch(arr, 0));
En supposant un tableau trié, voici une recherche binaire récursive:
function binSearch(needle, arr) {
length = arr.length;
while(length > 1) {
midpoint = Math.floor(length/2);
return (needle > arr[midpoint-1]) ?
binSearch(needle, arr.splice(midpoint, length)) :
binSearch(needle, arr.splice(0, midpoint));
}
return needle === arr[0] ? arr[0] : -1;
}
function binarySearch(arr, num, l, r){
if( arr instanceof Array ){
l = isNaN(l) ? 0 : l;
r = isNaN(r) ? arr.length - 1: r;
let mid = l + 1 + Math.round((r - l)/2 - 1);
console.log(l, r, mid, arr[mid]);
if( num == arr[mid] ){
console.log("found");
return mid;
}
if( typeof arr[mid] == "undefined" || l == r ){
console.log("not found"); return -1;
}
if( num < arr[mid] ){
console.log("take left");
return binarySearch(arr, num, l, r - mid);
}
console.log("take right");
return binarySearch(arr, num, mid, r);
}
}
console.log( binarySearch([0, 0, 1 ,1, 2, 3, 5, 6, 11], 2) );function binarySearch(a = [], x) {
let length = a.length;
if (length === 0) {
return false;
} else {
let m = Math.floor(length/2);
let y = a[m];
if (x === y) {
return true;
} else if (x < y) {
return binarySearch(a.slice(0, m), x);
} else {
return binarySearch(a.slice(m + 1), x);
}
}
}
Voici une fonction ES6 dans programming fonctionnelle style, qui utilise une fonction de comparaison par défaut si aucune donnée n'est fournie: si la valeur recherchée est du type numérique, la comparaison numérique sera utilisée, sinon la comparaison de chaînes.
function binarySearch(arr, val, compFunc =
(a, b) => typeof val == 'number' ? a-b : a.localeCompare(b), i=0, j=arr.length) {
return i >= j ? i
: ( mid =>
( cmp =>
cmp < 0 ? binarySearch(arr, val, compFunc, i, mid)
: cmp > 0 ? binarySearch(arr, val, compFunc, mid+1, j)
: mid
) (compFunc(val, arr[mid]))
) (i + j >> 1);
}
///////// Tests ///////////////////
function check(arr, val, compFunc) {
var fmt = JSON.stringify;
var result = binarySearch(arr, val); // default compFunc is assumed
console.log(`binarySearch(${fmt(arr)}, ${fmt(val)}) == ${fmt(result)}`);
if (result > arr.length || result < 0 || !arr.length && result
|| result < arr.length && compFunc(val, arr[result]) > 0
|| result > 0 && compFunc(val, arr[result-1]) < 0) throw "Unexpected result!!!"
}
// Tests with numeric data:
for (var val = 0; val < 12; val++)
check([1, 2, 4, 6, 9, 9, 10], val, (a,b) => a-b);
// Test with empty array:
check([], 12, (a,b) => a-b);
// Test with string data:
check(['abc', 'deaf', 'def', 'g'], 'dead', (a, b) => a.localeCompare(b));Bon après-midi, .__ Je crois comprendre que cet article a été lancé il y a quelque temps, mais je pensais pouvoir éventuellement contribuer à la discussion.
function binarySearch(array, target, max, min) {
//Find the Midpoint between forced max and minimum domain of the array
var mid = ((max - min) >> 1) + min;
//alert("Midpoint Number" + mid);
console.log(mid);
console.log(array[mid], "target: " + target);
if (array[mid] === target) {
//Target Value found
console.log('match', array[mid], target);
//alert('match', array[mid], target);
return mid;
}
else if (mid === 0)
{
//All Value have been checked, and none are the target value, return sentinel value
return -1;
}
else if (array[mid] > target)
{
//Value at Midpoint is greater than target Value, set new maximum to current midpoint
max = mid;
console.log('mid lower', array[mid], target);
//alert('mid lower', array[mid], target);
//Call binarySearch with new search domain
return binarySearch(array, target, max, min);
}
else if (array[mid] < target)
{
// Value at Midpoint is less than the target Value, set new minimum to current midpoint
min = mid;
console.log('mid higher', array[mid], target);
//alert('mid higher', array[mid], target);
//Call binarySearch with new search domain
return binarySearch(array, target, max, min);
}
Je suis sûr que des améliorations sont possibles ici, mais cette méthode évite de devoir effectuer une copie complète du tableau (ce qui peut être une action coûteuse lorsque vous travaillez avec un ensemble de données volumineux) et en même temps, elle ne modifie pas le tableau. de quelque manière que.
J'espère que ça aide! Merci, Jeremy
Supposons que le tableau est trié (écrivez votre propre algorithme trié ou utilisez simplement des méthodes intégrées)
function bSearch(array,item){
var start = 0,
end = item.length - 1;
var middle = Math.floor((end+start)/2);
while(array[middle] !== item && start < end){
if(item < array[middle]){
end = middle-1;
}
else if(item > array[middle]){
start = middle+1;
}
middle = Math.floor((end+start)/2);
}
if(array[item]!== middle){
console.log('notFoundMate);
return -1;
}
else {
console.log('FoundMate);
return middle;
}
}
J'ai une implémentation sur github avec une comparaison entre binaire et linéaire et une page de test si vous êtes toujours intéressé par d'autres implémentations ici