배열에서 가장 큰 값의 반환 인덱스

배열에서 가장 큰 값의 반환 인덱스

나는 다음을 가지고 있습니다.

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

가장 높은 값의 지수를 다른 변수로 되돌리는 가장 좋은 방법은 무엇입니까?

이 방법이 가장 좋은 방법일 것입니다. 오래된 브라우저에서 안정적이고 작동하기 때문입니다.

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

다음과 같은 하나의 라인도 있습니다.

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

필요한 것보다 두 배 더 많은 비교를 수행하고 결과를 산출합니다.RangeError하지만 대규모 어레이에서.저는 그 기능을 고수할 것입니다.

그보다 더 것입니다.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"

위치:

• iMax첫 번째 )iMax = 0 에대두 주때문에에 대한 두 입니다.reduce()이라0우리는 두 번째 주장을 생략할 수 없습니다.reduce()우리의 경우)
• x입니다.
• i 시험 중인
• arr우리들의 배열 ([0, 21, 22, 7])

에 reduce() "자바스크립트:데이비드 플래너건의 "최종 가이드":

reduction()은 두 개의 인수를 사용합니다.첫 번째는 축소 연산을 수행하는 기능입니다.이 축소 함수의 작업은 두 값을 어떤 식으로든 하나의 값으로 결합하거나 축소하고 그 축소된 값을 반환하는 것입니다.

reduction()과 함께 사용되는 함수는 Each()와 map()에 대해 에서 사용되는 함수와 다릅니다.익숙한 값, 인덱스 및 배열 값은 두 번째, 세 번째 및 네 번째 인수로 전달됩니다.첫 번째 주장은 지금까지 감소한 누적된 결과입니다.함수에 대한 첫 번째 호출에서 이 첫 번째 인수는 축소()하기 위한 두 번째 인수로 전달된 초기 값입니다.이후 호출 시 이전에 함수를 호출했을 때 반환되는 값입니다.

초기 값 없이 reduction()을 호출하면 배열의 첫 번째 요소가 초기 값으로 사용됩니다.즉, 축소 함수에 대한 첫 번째 호출에는 첫 번째 및 두 번째 배열 요소가 첫 번째 및 두 번째 인수로 포함됩니다.

최대 사용을 위한 또 다른 솔루션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]배열이 비어 있는 경우.만약당인원만한면다스덱이신,면원▁if▁put,다한,[1]후에.

(Minvia (으)로 )>그리고.MAX_VALUE):

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

@VFDan의 작업을 완료하기 위해 10000 플로트 어레이에서 허용된 방법(사용자 지정 루프), 축소 및 찾기(max(arr))의 세 가지 방법을 벤치마킹했습니다.

최소 85 Linux에서의 결과(높을수록 좋습니다):

• 사용자 지정 루프: 100%
• 감소: 94.36%
• 지수 Of(최대): 70%

파이어폭스 80 리눅스에서의 결과(높을수록 좋습니다):

• 사용자 지정 루프: 100%
• 감소: 96.39%
• 지수 Of(최대): 31.16%

결론:

코드를 빠르게 실행하려면 indexOf(max)를 사용하지 마십시오.축소는 괜찮지만 최상의 성능이 필요한 경우 사용자 지정 루프를 사용합니다.

다음 링크를 사용하여 다른 브라우저에서 이 벤치마크를 실행할 수 있습니다. https://jsben.ch/wkd4c

밑줄을 사용하는 경우 다음과 같은 짧은 원라이너를 사용할 수 있습니다.

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

먼저 배열에서 가장 큰 항목의 값(이 경우 22)을 찾습니다.그런 다음 22가 배열 내에 있는 인덱스(이 경우 2)를 반환합니다.

제가 틀리지 않는 한, 저는 그것이 당신 자신의 기능을 쓰기 위한 것이라고 말하고 싶습니다.

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

 var arr=[0,6,7,7,7];
 var largest=[0];
 //find the largest num;
 for(var i=0;i<arr.length;i++){
   var comp=(arr[i]-largest[0])>0;
      if(comp){
	  largest =[];
	  largest.push(arr[i]);
	  }
 }
 alert(largest )//7
 
 //find the index of 'arr'
 var arrIndex=[];
 for(var i=0;i<arr.length;i++){
    var comp=arr[i]-largest[0]==0;
	if(comp){
	arrIndex.push(i);
	}
 }
 alert(arrIndex);//[2,3,4]

편집: 수년 전에 저는 이것에 대해 징그럽고, 너무 구체적이고, 너무 복잡한 대답을 했습니다.그래서 편집하고 있습니다.위의 기능적 답변은 깔끔하지만 가독성은 좋지 않습니다. 하지만 제가 자바스크립트에 더 익숙했다면 그것도 좋아했을 것입니다.

유사 코드:

가장 큰 값을 포함하는 추적 인덱스입니다.인덱스 0이 처음에 가장 크다고 가정합니다.현재 인덱스와 비교합니다.필요한 경우 가장 큰 값으로 인덱스를 업데이트합니다.

코드:

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

통과하다arrayhaystack그리고.Math.max(...array)needle이렇게 하면 어레이의 모든 최대 요소가 제공되며 확장성이 향상됩니다(예: 최소값도 찾아야 함).

배열의 복사본을 만들고 내림차순으로 정렬하면 복사본의 첫 번째 요소가 가장 커집니다.원래 배열에서 인덱스를 찾을 수 있습니다.

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

시간 복잡도는 복사본의 경우 O(n), 정렬의 경우 O(n*log(n)), 인덱스 Of의 경우 O(n)입니다.

더 빨리 해야 한다면, Ry의 대답은 O(n)입니다.

@traxium 솔루션의 "축소" 버전에서 빈 배열을 고려하여 수정된 약간의 수정 사항:

function indexOfMaxElement(array) {
    return array.reduce((iMax, x, i, arr) => 
        arr[iMax] === undefined ? i :
        x > arr[iMax]           ? i : iMax
        , -1            // return -1 if empty
    );
}

이 기능의 안정적인 버전은 다음과 같습니다.

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

배열에서 가장 큰 값의 인덱스를 찾으려면 원래 배열을 새 배열로 복사한 다음 출력을 가져오는 순서로 원래 배열을 정렬합니다 [22, 21, 7, 0]. 이제 copyNumbers 배열에서 이 코드 copyNumbers.indexOf(numbers[0])를 사용하여 값 22 인덱스를 찾습니다.

<script>
  const numbers = [0, 21, 22, 7];
  const copyNumbers = [];
  copyNumbers.push(...numbers);
  numbers.sort(function(a, b){
    return b - a 
  });
  const index = copyNumbers.indexOf(numbers[0]);
  console.log(index);
</script>

이것을 만듦

const max = arr.max((m, n) => Math.max(m, n)), 그 다음 max의 인덱스

findIndex를 사용하여 인덱스

var 인덱스 = arr.findIndex(i => i === max)

언급URL : https://stackoverflow.com/questions/11301438/return-index-of-greatest-value-in-an-array