Question

我正在尝试编写一个函数，它在数组数组中找到两个最大值，并将它们存储在一个新数组中。我无法先删除原始阵列中的第一个最大数字，然后找到第二大数字。

这是我的代码：

function choseBig (myArray) {
    //var myArray = str.split(" "); 
    var result = [];
    var firstBig;
    var secondBig;
        // select the biggest value
        firstBig = Math.max.apply(Math, myArray);
        // find its index
        var index = myArray.indexOf(firstBig);
        // remove the biggest value from the original array 
        var myArray_2 = myArray.slice((index -1), 1);
        // choose the second biggest value
        secondBig = Math.max.apply(Math, myArray_2);
        // push the results into a new array
        result.push(firstBig, secondBig);

    return result;
}

console.log(choseBig ([1,2,3,4,5,9]));

Answer 1

乍一看，我建议：

function choseBig(myArray) {
  return myArray.sort((a, b) => b - a).slice(0, 2);
}

console.log(choseBig([1, 2, 3, 4, 5, 9]));

为了扩展上述内容，例如为用户提供指定返回值应该是最高数字，最低数字以及他们希望返回多少数量的选项，我提供以下内容：

function choseBig(myArray, opts) {
  // 'max':      Boolean,
  //             true:  returns the highest numbers,
  //             false: returns the lowest numbers
  // 'howMany':  Number,
  //             specifies how many numbers to return:
  var settings = {
      'max': true,
      'howMany': 2
    };

  // ensuring we have an Object, otherwise
  // Object.keys( opts ) returns an error:
  opts = opts || {};

  // retrieving the keys of the opts Object, and
  // uses Array.prototype.forEach() to iterate over
  // those keys; 'o' (in the anonymous function) is
  // the array element (the property-name/key) from
  // the array Object keys over which we're iterating:
  Object.keys(opts).forEach(function(o) {

    // updating the settings Object to the new values
    // (if any is specified) to those set in the user-
    // supplied opts Object:
    settings[o] = opts[o];
  });

  // here we first sort the Array, using a numeric sort;
  // using ES2015 Arrow functions. 'a' and 'b' are supplied
  // by Array.prototype.sort() and refer to the current ('a')
  // and next ('b') array-elements. If b - a is less than zero
  // b is moved to a lower index; if a - b is less than zero
  // a is moved to a lower index.
  // Here we use a ternary operator based on whether settings.max
  // is true; if it is true we sort to move the larger number to
  // the lower index; otherwise we sort to move the smaller number
  // to the lower index.
  // Then we slice the resulting array to return the numbers from
  // the 0 index (the first number) to the settings.howMany number
  // (the required length of the array).
  // this is then returned to the calling context.
  return myArray.sort((a, b) => settings.max === true ? b - a : a - b).slice(0, settings.howMany);
}

console.log(choseBig([1, 2, 3, 4, 5, 9], {
  // here we specify to select the largest numbers:
  'max': true,
  // we specify we want the 'top' three numbers:
  'howMany': 3
}));

＆＃13;

function choseBig(myArray, opts) {
  var settings = {
    'max': true,
    'howMany': 2
  };

  opts = opts || {};

  Object.keys(opts).forEach(function(o) {
    settings[o] = opts[o];
  });

  return myArray.sort((a, b) => settings.max === true ? b - a : a - b).slice(0, settings.howMany);
}

console.log(choseBig([1, 2, 3, 4, 5, 9], {
  'max': true,
  'howMany': 3
}));

＆＃13;

JS Fiddle demo

参考文献：

Answer 2

为什么不对它进行排序（降序）并获取前两个条目

biggest = myArray.sort(function(a,b){return b - a}).slice(0,2);

Answer 3

上面的答案可能更好，更紧凑，但如果您不想使用/* Cover */ #tom{ bottom: 40px; left: 45%; min-width: 55%; max-width: 55%; padding: 12px; -webkit-box-reflect: below -70px -webkit-gradient(linear, left top, left bottom, from(transparent), color-stop(78%, transparent), to(white)); } .cover img{ float: right; }，这是另一种选择

sort()

Answer 4

Array#reduce的线性解决方案，无需排序。

＆＃13;

var array = [1, 2, 3, 4, 5, 9],
    biggest = array.reduce(function (r, a) {
        if (a > r[1]) {
            return [r[1], a];
        }
        if (a > r[0]) {
            return [a, r[1]];
        }
        return r;
    }, [-Number.MAX_VALUE, -Number.MAX_VALUE]);

document.write('<pre>' + JSON.stringify(biggest, 0, 4) + '</pre>');

＆＃13;

编辑：不止一个最大值

＆＃13;

var array = [1, 2, 3, 4, 5, 9, 9],
    biggest = array.reduce(function (r, a) {
        if (a > r[1]) {
            return [r[1], a];
        }
        if (a > r[0]) {
            return [a, r[1]];
        }
        return r;
    }, [-Number.MAX_VALUE, -Number.MAX_VALUE]);

document.write('<pre>' + JSON.stringify(biggest, 0, 4) + '</pre>');

＆＃13;

Answer 5

如果要以非破坏性方式（例如，不更改原始数组）从数值数组中检索最大的两个值，并且您希望使其可扩展，那么您可以要求N最大并按顺序返回，你可以这样做：

function getLargestN(array, n) {
    return array.slice(0).sort(function(a, b) {return b - a;}).slice(0, n);
}

而且，这是一个包含一些测试数据的工作片段：

function getLargestN(array, n) {
    return array.slice(0).sort(function(a, b) {return b - a;}).slice(0, n);
}

// run test data
var testData = [
    [5,1,2,3,4,9], 2,
    [1,101,22,202,33,303,44,404], 4,
    [9,8,7,6,5], 2
];

for (var i = 0; i < testData.length; i+=2) {
    if (i !== 0) {
        log('<hr style="width: 50%; margin-left: 0;">');
    }
    log("input: ", testData[i], " :", testData[i+1]);
    log("output: ", getLargestN(testData[i], testData[i+1]));
}

<script src="http://files.the-friend-family.com/log.js"></script>

Answer 6

使用Math#max和Array#splice

var first = Math.max(...arr)
arr.splice(arr.indexOf(first))
var second = Math.max(...arr)

并使用ES6 spread operator

Answer 7

我喜欢the linear solution of Nina Scholz。这是另一个版本。

function chooseBig (myArray) {
   var a = myArray[0], b = myArray[0];
   for(i = 1; i < myArray.length; i++) {
       if (myArray[i] === a) {
           continue;
       } else if (myArray[i] > a) {
           b = a;
           a = myArray[i];
       } else if (myArray[i] > b || a === b) {
           b= myArray[i];
       }
   }
   return [a, b];
}

Answer 8

[1,101,22,202].sort(function(a, b){return b-a})[0]
[1,101,22,202].sort(function(a, b){return b-a})[1]

选择数组中的两个最大值

8 个答案: