如何正确排序整数数组

Question

试图从我知道的数组中获得最高和最低值只包含整数似乎比我想象的要难.

var numArray = [140000, 104, 99];
numArray = numArray.sort();
alert(numArray)

我希望这能表明99, 104, 140000.相反它显示104, 140000, 99.所以似乎排序是将值作为字符串处理.

有没有办法让sort函数实际对整数值进行排序？

Answer 1

默认情况下,sort方法按字母顺序对元素进行排序.要以数字方式排序,只需添加一个处理数字排序的新方法(sortNumber,如下所示) -

function sortNumber(a, b) {
  return a - b;
}

var numArray = [140000, 104, 99];
numArray.sort(sortNumber);

console.log(numArray);

编辑:使用ES6箭头功能:

numArray.sort((a, b) => a - b); // For ascending sort
numArray.sort((a, b) => b - a); // For descending sort

Answer 2

只要建立在上述所有答案的基础上,它们也可以在一行中完成,如下所示:

var numArray = [140000, 104, 99];

// ES5
numArray = numArray.sort(function (a, b) {  return a - b;  });

// ES2015
numArray = numArray.sort((a, b) => a - b);

//outputs: 99, 104, 140000

Answer 3

array.sort默认使用字典排序,对于数字排序,提供自己的函数.这是一个简单的例子:

function compareNumbers(a, b)
{
    return a - b;
}

numArray.sort(compareNumbers);

另请注意,排序工作"就地",不需要分配.

Answer 4

只是做.sort((a, b) => a - b)而不是.sort()它自己。除此之外，该数组已就地排序。所以返回值并不重要。

var numArray = [140000, 104, 99];
numArray.sort((a, b) => a - b);
console.log(numArray)

Answer 5

这个答案等同于一些现有的答案,但ECMAScript 6 箭头函数提供了更紧凑的语法,允许我们在不牺牲可读性的情况下定义内联排序函数:

numArray = numArray.sort((a, b) => a - b);

今天大多数浏览器都支持它.

Answer 6

我很惊讶为什么每个人都建议将比较器功能传递给sort(),这使得排序真的很慢!

要对数字进行排序,只需创建任何 TypedArray:

var numArray = new Uint32Array([140000, 104, 99]);
numArray = numArray.sort();
alert(numArray)

Answer 7

上升

arr.sort((a, b) => a - b);

降序

arr.sort((a, b) => b - a);

只是为了好玩：

降序 = 升序 + 反向

arr.sort((a, b) => a - b).reverse();

Answer 8

sort函数表现得如此奇怪的原因

从文档:

[...]根据每个元素的字符串转换,根据每个字符的Unicode代码点值对数组进行排序.

如果打印数组的unicode点值,那么它将变得清晰.

console.log("140000".charCodeAt(0));
console.log("104".charCodeAt(0));
console.log("99".charCodeAt(0));

//Note that we only look at the first index of the number "charCodeAt(  0  )"

返回:"49,49,57".

49 (unicode value of first number at 140000)
49 (unicode value of first number at 104)
57 (unicode value of first number at 99)

现在,因为140000和104返回相同的值(49),它会切断第一个索引并再次检查:

console.log("40000".charCodeAt(0));
console.log("04".charCodeAt(0));

//Note that we only look at the first index of the number "charCodeAt(  0  )"

52 (unicode value of first number at 40000)
40 (unicode value of first number at 04)

如果我们对此进行排序,那么我们将获得:

40 (unicode value of first number at 04)
52 (unicode value of first number at 40000)

所以104在140000之前.

所以最终结果将是:

var numArray = [140000, 104, 99];
numArray = numArray.sort();
console.log(numArray)

104, 140000, 99

结论:

sort()仅通过查看数字的第一个索引进行排序.sort()并不关心整数是否大于另一个,它比较数字的unicode值,如果有两个相等的unicode值,则检查是否有下一个数字并进行比较.

要正确排序,您必须将比较函数传递给此处sort()说明的内容.

Answer 9

我同意aks,但不是使用

return a - b;

你应该用

return a > b ? 1 : a < b ? -1 : 0;

Answer 10

Array.sort默认情况下使用字母排序而不是数字排序。

要支持数字，请添加如下内容

var numArray = [140000, 104, 99];
numArray.sort((a, b) =>  a - b); // <-- Ascending
numArray.sort((a, b) =>  b - a); // <-- Descending
console.log(numArray);

输出 ：

Answer 11

在JavaScript中,sort()方法的默认行为是按字母顺序对数组中的值进行排序.

要按数字排序,您必须定义数字排序函数(这非常简单):

...
function sortNumber(a, b)
{
  return a - b;
}

numArray = numArray.sort(sortNumber);

Answer 12

在新的ES6世界中,它更容易进行排序

numArray.sort((a,b) => a-b);

多数民众赞成你需要:)

Answer 13

Array.prototype.sort()是用于排序数组的方法,但是我们需要注意一些问题.

无论数组中的值类型如何,排序顺序都是默认的词典,而不是数字.即使数组是所有数字,所有值都将转换为字符串并按字典顺序排序.

那么我们是否需要自定义sort()和reverse()方法,如下所示.

推荐的网址

用于排序数组内的数字

numArray.sort(function(a, b)
{
    return a - b;
});

用于反转数组内的数字

numArray.sort(function(a, b)
{
    return b - a;
});

推荐的网址

Answer 14

问题已经回答，最短的方法就是使用sort()方法。但是，如果您正在寻找更多方式对数字数组进行排序，并且您也喜欢循环，请检查以下内容

插入排序

上升：

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length; i++) {
    var target = numArray[i];
    for (var j = i - 1; j >= 0 && (numArray[j] > target); j--) {
        numArray[j+1] = numArray[j];
    }
    numArray[j+1] = target
}
console.log(numArray);

降序：

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length; i++) {
    var target = numArray[i];
    for (var j = i - 1; j >= 0 && (numArray[j] < target); j--) {
        numArray[j+1] = numArray[j];
    }
    numArray[j+1] = target
}
console.log(numArray);

选择排序：

上升：

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length - 1; i++) {
    var min = i;
    for (var j = i + 1; j < numArray.length; j++) {
        if (numArray[j] < numArray[min]) {
            min = j;
        }
    }
    if (min != i) {
        var target = numArray[i];
        numArray[i] = numArray[min];
        numArray[min] = target;
    }
}
console.log(numArray);

降序：

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length - 1; i++) {
    var min = i;
    for (var j = i + 1; j < numArray.length; j++) {
        if (numArray[j] > numArray[min]) {
            min = j;
        }
    }
    if (min != i) {
        var target = numArray[i];
        numArray[i] = numArray[min];
        numArray[min] = target;
    }
}
console.log(numArray);

玩得开心

Answer 15

处理 undefined、null 和 NaN：Null 的行为类似于 0、NaN 和 undefined 结束。

array = [3, 5, -1, 1, NaN, 6, undefined, 2, null]
array.sort((a,b) => isNaN(a) || a-b)
// [-1, null, 1, 2, 3, 5, 6, NaN, undefined]

Answer 16

当作为回调函数提供时，下面的“按数字”功能可用于对数字数组进行数字排序：

function numerically(a, b){
    return a-b;
}

array.sort(numerically); 

但是在某些罕见的情况下，数组包含非常大的负数，由于ab的结果小于JavaScript可以处理的最小数，所以会发生溢出错误。

因此，编写数字函数的更好方法如下：

function numerically(a, b){
   if(a < b){
      return -1;
   } else if(a > b){
      return 1;
   } else {
      return 0;
   }
}

Answer 17

numArray.sort((a,b) => a - b)当数组仅包含没有无穷大或 NaN 的数字时，接受的答案和等价物就很好。它们可以扩展为处理无穷大和 NaN，如下所示：

numArray.sort((a,b) => (+a || 0) - (+b || 0) || 0);

这会将 NaN（或任何非数字，如 'foo' 或 {}）视为 0 进行排序。|| 0需要使用 Final 来处理 a 和 b 相等无穷大的情况。