Bir dizideki en büyük değerin dönüş dizini

Bu bende var:

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

En yüksek değerin dizinini başka bir değişkene döndürmenin en iyi yolu nedir?

Güvenilir olduğu ve eski tarayıcılarda çalıştığı için bu muhtemelen en iyi yoldur:

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

Bir de şu tek satırlık var:

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

Gerektiğinde iki kat daha fazla karşılaştırma yapar ve yine de RangeErrorbüyük dizilere bir atar . İşleve bağlı kalırım.

Tek satırda ve muhtemelen daha hızlı 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"

Nerede:

• iMax- En iyi endeks bugüne kadar (birinci tekrar bugüne kadar maksimum elemanın indeksi, iMax = 0ikinci argüman çünkü reduce()olduğunu 0, biz ikinci argüman geçemeyeceğim reduce()bizim durumumuzda)
• x - diziden şu anda test edilen öğe
• i - şu anda test edilen indeks
• arr- dizimiz ( [0, 21, 22, 7])

Hakkında reduce()(: David Flanagan tarafından "Kesin Kılavuzu JavaScript" dan) yöntemiyle:

azaltma () iki argüman alır. Birincisi, küçültme işlemini gerçekleştiren işlevdir. Bu indirgeme işlevinin görevi, iki değeri bir şekilde tek bir değerde birleştirmek veya azaltmak ve bu indirgenmiş değeri döndürmektir.

Low () ile kullanılan fonksiyonlar, forEach () ve map () ile kullanılan fonksiyonlardan farklıdır. Tanıdık değer, dizin ve dizi değerleri ikinci, üçüncü ve dördüncü bağımsız değişkenler olarak aktarılır. İlk argüman, şimdiye kadarki indirgemenin birikmiş sonucudur. İşleve ilk çağrıda, bu ilk bağımsız değişken, azaltma () için ikinci bağımsız değişken olarak ilettiğiniz ilk değerdir. Sonraki çağrılarda, işlevin önceki çağrısı tarafından döndürülen değerdir.

Başlangıç ​​değeri olmadan azaltma () 'yı çağırdığınızda, dizinin ilk öğesini başlangıç ​​değeri olarak kullanır. Bu, azaltma işlevine yapılan ilk çağrının, birinci ve ikinci argümanları olarak birinci ve ikinci dizi öğelerine sahip olacağı anlamına gelir.

İşte başka bir çözüm: Yayılma operatörünü kullanarak ES6 kullanıyorsanız:

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

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

Yanılmıyorsam, kendi fonksiyonunuzu yazmanız gerektiğini söyleyebilirim.

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

Alt çizgi kullanıyorsanız, bu güzel kısa tek satırlık çizgiyi kullanabilirsiniz:

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

İlk önce dizideki en büyük öğenin değerini, bu durumda 22'yi bulacaktır. Daha sonra dizi içinde 22'nin bulunduğu dizini, bu durumda 2'yi döndürecektir.

Max kullanmanın başka bir çözümü reduce:

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

[5e-324, -1]Dizi boşsa bu döndürülür . Sadece dizini istiyorsanız, [1]sonrasına koyun .

Min aracılığıyla ( >ve Değiştir MAX_VALUE):

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

DÜZENLEME: Yıllar önce buna kaba, çok özel ve çok karmaşık bir cevap verdim. Ben de düzenliyorum. Yukarıdaki işlevsel cevapları temiz faktörleri için tercih ediyorum, ancak okunabilirlikleri değil; ama javascript'e daha aşina olsaydım, onun için de hoşuma gidebilirdi.

Sözde kod:

En büyük değeri içeren izleme dizini. 0 indisinin başlangıçta en büyük olduğunu varsayalım. Mevcut endeksle karşılaştırın. Gerekirse dizini en büyük değere sahip güncelleyin.

Kod:

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

geçmesi arrayiçin haystackve Math.max(...array)için needle. Bu , dizinin tüm maksimum elemanlarını verir ve daha fazla genişletilebilirdir (örneğin, ayrıca minimum değerleri bulmanız gerekir)

Dizinin bir kopyasını oluşturur ve azalan sıralarsanız, kopyanın ilk öğesi en büyük olacaktır. Daha sonra dizinini orijinal dizide bulabilirsiniz.

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

Zaman karmaşıklığı kopya için O (n), sıralama için O (n * log (n)) ve indexOf için O (n) şeklindedir.

Daha hızlı yapmanız gerekiyorsa, Ry'nin cevabı O (n).

Bu işlevin kararlı bir sürümü şuna benzer:

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