Retourne l'index de la plus grande valeur dans un tableau

J'ai ceci:

var arr = [0, 21, 22, 7];

Quelle est la meilleure façon de renvoyer l'index de la valeur la plus élevée dans une autre variable?

C'est probablement le meilleur moyen, car il est fiable et fonctionne sur les anciens navigateurs:

function indexOfMax(arr) {
    if (arr.length === 0) {
        return -1;
    }

    var max = arr[0];
    var maxIndex = 0;

    for (var i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            maxIndex = i;
            max = arr[i];
        }
    }

    return maxIndex;
}

Il y a aussi ce one-liner:

let i = arr.indexOf(Math.max(...arr));

Il effectue deux fois plus de comparaisons que nécessaire et lancera un RangeErrorsur les grands tableaux, cependant. Je m'en tiendrai à la fonction.

En une ligne et probablement plus rapide alors arr.indexOf(Math.max.apply(Math, arr)):

var a = [0, 21, 22, 7];
var indexOfMaxValue = a.reduce((iMax, x, i, arr) => x > arr[iMax] ? i : iMax, 0);

document.write("indexOfMaxValue = " + indexOfMaxValue); // prints "indexOfMaxValue = 2"

Où:

• iMax- le meilleur index jusqu'à présent (l'index de l'élément max jusqu'à présent, à la première itération iMax = 0car le deuxième argument de reduce()est 0, nous ne pouvons pas omettre le deuxième argument dereduce() dans notre cas)
• x - l'élément actuellement testé du tableau
• i - l'indice actuellement testé
• arr- notre tableau ( [0, 21, 22, 7])

À propos de la reduce()méthode (extrait de "JavaScript: The Definitive Guide" de David Flanagan):

réduire () prend deux arguments. La première est la fonction qui effectue l'opération de réduction. La tâche de cette fonction de réduction est de combiner ou de réduire d'une manière ou d'une autre deux valeurs en une seule valeur et de renvoyer cette valeur réduite.

Les fonctions utilisées avec Reduce () sont différentes des fonctions utilisées avec forEach () et map (). Les valeurs familières de valeur, d'index et de tableau sont transmises en tant que deuxième, troisième et quatrième arguments. Le premier argument est le résultat cumulé de la réduction jusqu'à présent. Lors du premier appel à la fonction, ce premier argument est la valeur initiale que vous avez passée en tant que deuxième argument à réduire (). Lors des appels suivants, il s'agit de la valeur renvoyée par l'appel précédent de la fonction.

Lorsque vous appelez reduction () sans valeur initiale, il utilise le premier élément du tableau comme valeur initiale. Cela signifie que le premier appel à la fonction de réduction aura les premier et deuxième éléments du tableau comme premier et deuxième arguments.

Voici une autre solution, si vous utilisez ES6 en utilisant l'opérateur de propagation:

var arr = [0, 21, 22, 7];

const indexOfMaxValue = arr.indexOf(Math.max(...arr));

Sauf erreur, je dirais que c'est pour écrire votre propre fonction.

function findIndexOfGreatest(array) {
  var greatest;
  var indexOfGreatest;
  for (var i = 0; i < array.length; i++) {
    if (!greatest || array[i] > greatest) {
      greatest = array[i];
      indexOfGreatest = i;
    }
  }
  return indexOfGreatest;
}

Si vous utilisez un trait de soulignement, vous pouvez utiliser ce joli short one-liner:

_.indexOf(arr, _.max(arr))

Il trouvera d'abord la valeur du plus grand élément du tableau, dans ce cas 22. Ensuite, il retournera l'index de l'endroit où 22 se trouve dans le tableau, dans ce cas 2.

Une autre solution de max utilisant reduce:

[1,2,5,0,4].reduce((a,b,i) => a[0] < b ? [b,i] : a, [Number.MIN_VALUE,-1])
//[5,2]

Cela renvoie [5e-324, -1]si le tableau est vide. Si vous voulez juste l'index, mettez[1] après.

Min via (Changer en >et MAX_VALUE):

[1,2,5,0,4].reduce((a,b,i) => a[0] > b ? [b,i] : a, [Number.MAX_VALUE,-1])
//[0, 3]

EDIT: Il y a des années, j'ai donné une réponse à cela qui était grossière, trop précise et trop compliquée. Alors je le modifie. Je préfère les réponses fonctionnelles ci-dessus pour leur aspect soigné mais pas pour leur lisibilité; mais si j'étais plus familier avec javascript, je les aimerais peut-être aussi pour cela.

Pseudo code:

Index de suivi contenant la plus grande valeur. Supposons que l'indice 0 soit le plus grand au départ. Comparez avec l'index actuel. Mettez à jour l'index avec la valeur la plus élevée si nécessaire.

Code:

var mountains = [3, 1, 5, 9, 4];

function largestIndex(array){
  var counter = 1;
  var max = 0;

  for(counter; counter < array.length; counter++){
    if(array[max] < array[counter]){
        max = counter;
    }
  }
  return max;
}

console.log("index with largest value is: " +largestIndex(mountains));
// index with largest value is: 3

function findIndicesOf(haystack, needle)
{
    var indices = [];

    var j = 0;
    for (var i = 0; i < haystack.length; ++i) {
        if (haystack[i] == needle)
            indices[j++] = i;
    }
    return indices;
}

passer arrayà haystacket Math.max(...array)à needle. Cela donnera tous les éléments max du tableau, et il est plus extensible (par exemple, vous devez également trouver des valeurs min)

Si vous créez une copie du tableau et le triez par ordre décroissant, le premier élément de la copie sera le plus grand. Ensuite, vous pouvez trouver son index dans le tableau d'origine.

var sorted = [...arr].sort((a,b) => b - a)
arr.indexOf(sorted[0])

La complexité en temps est O (n) pour la copie, O (n * log (n)) pour le tri et O (n) pour l'indexOf.

Si vous devez le faire plus rapidement, la réponse de Ry est O (n).

Une version stable de cette fonction ressemble à ceci:

// not defined for empty array
function max_index(elements) {
    var i = 1;
    var mi = 0;
    while (i < elements.length) {
        if (!(elements[i] < elements[mi]))
            mi = i;
        i += 1;
    }
    return mi;
}