Índice de retorno de mayor valor en una matriz

Tengo esto:

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

¿Cuál es la mejor manera de devolver el índice del valor más alto en otra variable?

Esta es probablemente la mejor manera, ya que es confiable y funciona en navegadores antiguos:

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;
}

También hay esta frase:

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

Sin RangeErrorembargo, realiza el doble de comparaciones que sea necesario y arrojará una en matrices grandes. Me apegaría a la función.

En una línea y probablemente más rápido que 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"

Dónde:

• iMax- el mejor índice hasta ahora (el índice del elemento max hasta ahora, en la primera iteración iMax = 0porque el segundo argumento reduce()es 0, no podemos omitir el segundo argumento reduce()en nuestro caso)
• x - el elemento actualmente probado de la matriz
• i - el índice actualmente probado
• arr- nuestra matriz ( [0, 21, 22, 7])

Sobre el reduce()método (de "JavaScript: la guía definitiva" de David Flanagan):

reduce () toma dos argumentos. La primera es la función que realiza la operación de reducción. La tarea de esta función de reducción es de alguna manera combinar o reducir dos valores en un solo valor, y devolver ese valor reducido.

Las funciones utilizadas con reduce () son diferentes a las funciones utilizadas con forEach () y map (). El valor familiar, el índice y los valores de matriz se pasan como segundo, tercer y cuarto argumento. El primer argumento es el resultado acumulado de la reducción hasta ahora. En la primera llamada a la función, este primer argumento es el valor inicial que pasó como segundo argumento para reducir (). En llamadas posteriores, es el valor devuelto por la invocación previa de la función.

Cuando invoca reduce () sin valor inicial, utiliza el primer elemento de la matriz como valor inicial. Esto significa que la primera llamada a la función de reducción tendrá el primer y el segundo elemento de la matriz como su primer y segundo argumento.

Aquí hay otra solución, si está utilizando ES6 utilizando el operador de propagación:

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

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

A menos que me equivoque, diría que es escribir su propia función.

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 está utilizando guiones bajos, puede utilizar este breve resumen:

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

Primero encontrará el valor del elemento más grande en la matriz, en este caso 22. Luego devolverá el índice de donde 22 está dentro de la matriz, en este caso 2.

Otra solución de max usando reduce:

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

Esto vuelve [5e-324, -1]si la matriz está vacía. Si solo quieres el índice, ponlo [1]después.

Min via (Cambiar a >y MAX_VALUE):

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

EDITAR: Hace años le di una respuesta a esto que era asquerosa, demasiado específica y demasiado complicada. Entonces lo estoy editando. Estoy a favor de las respuestas funcionales anteriores por su factor ordenado pero no por su legibilidad; pero si estuviera más familiarizado con javascript, entonces también me gustaría para eso.

Pseudocódigo:

Índice de seguimiento que contiene el mayor valor. Suponga que el índice 0 es el más grande inicialmente. Comparar con el índice actual. Actualice el índice con el mayor valor si es necesario.

Código:

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;
}

pasar arraya haystacky Math.max(...array)a needle. Esto le dará todos los elementos máximos de la matriz, y es más extensible (por ejemplo, también necesita encontrar valores mínimos)

Si crea una copia de la matriz y la ordena descendiendo, el primer elemento de la copia será el más grande. Entonces puede encontrar su índice en la matriz original.

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

La complejidad temporal es O (n) para la copia, O (n * log (n)) para la clasificación y O (n) para el indexOf.

Si necesita hacerlo más rápido, la respuesta de Ry es O (n).

Una versión estable de esta función se ve así:

// 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;
}

Sencillo

maxarr: function(){
let maxval = 0;
let maxindex = null;
for (i = 0; i < arr.length; i++){
if (arr[i] > maxval) {
maxval = arr[i];
maxindex = i;
}
}
}