Gibt den Index des größten Werts in einem Array zurück

Ich habe das:

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

Wie kann der Index des höchsten Werts am besten in eine andere Variable zurückgegeben werden?

Dies ist wahrscheinlich der beste Weg, da es zuverlässig ist und mit alten Browsern funktioniert:

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

Es gibt auch diesen Einzeiler:

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

Es führt doppelt so viele Vergleiche wie nötig durch und wirft jedoch RangeErrorgroße Arrays auf. Ich würde mich an die Funktion halten.

In einer Zeile und wahrscheinlich schneller als 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"

Wo:

• iMax- der beste Index so weit (der Index des max - Elements so weit, auf der ersten Iteration , iMax = 0da das zweite Argument reduce()ist 0, können wir nicht das zweite Argument weglassen reduce()in unserem Fall)
• x - das aktuell getestete Element aus dem Array
• i - der aktuell getestete Index
• arr- unser Array ( [0, 21, 22, 7])

Über die reduce()Methode (aus "JavaScript: The Definitive Guide" von David Flanagan):

redu () benötigt zwei Argumente. Die erste ist die Funktion, die die Reduktionsoperation ausführt. Die Aufgabe dieser Reduktionsfunktion besteht darin, zwei Werte irgendwie zu einem einzigen Wert zu kombinieren oder zu reduzieren und diesen reduzierten Wert zurückzugeben.

Mit redu () verwendete Funktionen unterscheiden sich von den mit forEach () und map () verwendeten Funktionen. Die bekannten Werte für Wert, Index und Array werden als zweites, drittes und viertes Argument übergeben. Das erste Argument ist das akkumulierte Ergebnis der bisherigen Reduzierung. Beim ersten Aufruf der Funktion ist dieses erste Argument der Anfangswert, den Sie als zweites zu reduzierendes Argument () übergeben haben. Bei nachfolgenden Aufrufen ist dies der Wert, der vom vorherigen Aufruf der Funktion zurückgegeben wurde.

Wenn Sie redu () ohne Anfangswert aufrufen, wird das erste Element des Arrays als Anfangswert verwendet. Dies bedeutet, dass der erste Aufruf der Reduktionsfunktion das erste und das zweite Array-Element als erstes und zweites Argument enthält.

Hier ist eine andere Lösung: Wenn Sie ES6 mit dem Spread-Operator verwenden:

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

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

Wenn ich mich nicht irre, würde ich sagen, dass es darum geht, eine eigene Funktion zu schreiben.

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

Wenn Sie einen Unterstrich verwenden, können Sie diesen schönen kurzen Einzeiler verwenden:

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

In diesem Fall wird zuerst der Wert des größten Elements im Array ermittelt, in diesem Fall 22. Anschließend wird der Index zurückgegeben, in dem sich 22 innerhalb des Arrays befindet, in diesem Fall 2.

Eine andere Lösung von max mit reduce:

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

Dies wird zurückgegeben, [5e-324, -1]wenn das Array leer ist. Wenn Sie nur den Index möchten, setzen Sie [1]nach.

Min via (Wechsel zu >und MAX_VALUE):

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

EDIT: Vor Jahren gab ich eine Antwort darauf, die grob, zu spezifisch und zu kompliziert war. Also bearbeite ich es. Ich bevorzuge die obigen funktionalen Antworten wegen ihres ordentlichen Faktors, aber nicht wegen ihrer Lesbarkeit. aber wenn ich mit Javascript besser vertraut wäre, würde ich sie vielleicht auch dafür mögen.

Pseudocode:

Verfolgen Sie den Index, der den größten Wert enthält. Angenommen, Index 0 ist anfangs am größten. Vergleichen Sie mit dem aktuellen Index. Aktualisieren Sie gegebenenfalls den Index mit dem größten Wert.

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

weitergeben arrayzu haystackund Math.max(...array)zu needle. Dies gibt alle max-Elemente des Arrays an und ist erweiterbarer (zum Beispiel müssen Sie auch min-Werte finden).

Wenn Sie eine Kopie des Arrays erstellen und absteigend sortieren, ist das erste Element der Kopie das größte. Dann finden Sie den Index im ursprünglichen Array.

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

Die zeitliche Komplexität beträgt O (n) für die Kopie, O (n * log (n)) für die Sortierung und O (n) für den Index.

Wenn Sie es schneller machen müssen, lautet Rys Antwort O (n).

Eine stabile Version dieser Funktion sieht folgendermaßen aus:

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

Einfach

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