Mengembalikan indeks nilai terbesar dalam array

Aku punya ini:

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

Apa cara terbaik untuk mengembalikan indeks dari nilai tertinggi ke variabel lain?

Ini mungkin cara terbaik, karena dapat diandalkan dan berfungsi di browser lama:

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

Ada juga satu kalimat ini:

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

Itu melakukan perbandingan dua kali lebih banyak yang diperlukan dan akan melemparkan RangeErrorpada array yang besar, meskipun. Saya akan tetap berpegang pada fungsinya.

Dalam satu baris dan mungkin lebih cepat, maka 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"

Dimana:

• iMax- indeks terbaik sejauh ini (indeks elemen maks sejauh ini, pada iterasi pertama iMax = 0karena argumen kedua reduce()adalah 0, kita tidak dapat menghilangkan argumen kedua reduce()dalam kasus kami)
• x - elemen yang saat ini diuji dari array
• i - indeks yang saat ini diuji
• arr- array kami ( [0, 21, 22, 7])

Tentang reduce()metode (dari "JavaScript: The Definitive Guide" oleh David Flanagan):

mengurangi () membutuhkan dua argumen. Yang pertama adalah fungsi yang melakukan operasi pengurangan. Tugas fungsi reduksi ini adalah entah bagaimana menggabungkan atau mengurangi dua nilai menjadi nilai tunggal, dan mengembalikan nilai yang dikurangi tersebut.

Fungsi yang digunakan dengan mengurangi () berbeda dari fungsi yang digunakan dengan forEach () dan peta (). Nilai akrab, indeks, dan nilai array dilewatkan sebagai argumen kedua, ketiga, dan keempat. Argumen pertama adalah akumulasi hasil pengurangan sejauh ini. Pada panggilan pertama ke fungsi, argumen pertama ini adalah nilai awal yang Anda berikan sebagai argumen kedua untuk mengurangi (). Pada panggilan berikutnya, itu adalah nilai yang dikembalikan oleh pemanggilan fungsi sebelumnya.

Saat Anda memanggil pengurangan () tanpa nilai awal, ia menggunakan elemen pertama array sebagai nilai awal. Ini berarti bahwa panggilan pertama ke fungsi reduksi akan memiliki elemen array pertama dan kedua sebagai argumen pertama dan kedua.

Berikut adalah solusi lain, Jika Anda menggunakan ES6 menggunakan operator spread:

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

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

Kecuali saya salah, saya akan mengatakan itu untuk menulis fungsi Anda sendiri.

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

Jika Anda menggunakan garis bawah, Anda dapat menggunakan kalimat singkat berikut:

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

Pertama-tama akan menemukan nilai item terbesar dalam array, dalam hal ini 22. Kemudian akan mengembalikan indeks di mana 22 berada dalam array, dalam hal ini 2.

Solusi lain menggunakan max reduce:

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

Ini mengembalikan [5e-324, -1]jika array kosong. Jika Anda ingin hanya indeks, taruh [1]setelah.

Min via (Ubah ke >dan MAX_VALUE):

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

EDIT: Bertahun-tahun yang lalu saya memberikan jawaban untuk ini yang kotor, terlalu spesifik, dan terlalu rumit. Jadi saya mengeditnya. Saya menyukai jawaban fungsional di atas untuk faktor rapi tetapi tidak mudah dibaca; tetapi jika saya lebih terbiasa dengan javascript maka saya mungkin akan menyukainya juga.

Kode palsu:

Lacak indeks yang berisi nilai terbesar. Asumsikan indeks 0 adalah yang terbesar pada awalnya. Bandingkan dengan indeks saat ini. Perbarui indeks dengan nilai terbesar jika perlu.

Kode:

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

lolos arraydari haystackdan Math.max(...array)ke needle. Ini akan memberikan semua elemen max dari array, dan itu lebih dapat diperluas (misalnya, Anda juga perlu menemukan nilai min)

Jika Anda membuat salinan array dan mengurutkannya, elemen pertama dari salinan akan menjadi yang terbesar. Daripada Anda dapat menemukan indeks dalam array asli.

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

Kompleksitas waktu adalah O (n) untuk salinan, O (n * log (n)) untuk penyortiran dan O (n) untuk indexOf.

Jika Anda perlu melakukannya lebih cepat, jawaban Ry adalah O (n).

Versi stabil dari fungsi ini terlihat seperti ini:

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

Sederhana

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