实施例

输入数组：[1,2,-3,-2,4]
输出数组：[-3,-2,1,2,4]

输入数组：[3,2,-1,0,-4,3,6,-7,-6]
输出数组：[-1,-4,-7,-6,3,2,0,3,6]

我可以使用push（）方法使用临时数组，但是如何在不使用该数组中的临时数组的情况下执行此操作？

Answer 1

使用 sort()

＆＃13;

var res = [1, 2, -3, -2, 4].sort(function(a, b) {
  return a - b;
});

// or just use, var res = [1, 2, -3, -2, 4].sort();

document.write(JSON.stringify(res));

＆＃13;

要根据需要进行排序，您需要添加自定义排序条件。

更新在您的情况下， sort() 不会保留相同值项的位置，因此您可以使用 filter() 和 concat() 即可。使用 filter() 在不同数组中获取负数，零数和正数后，使用 concat() 将其连接到您想要的任何顺序。

＆＃13;

var res = [3, 4, -6, 0, -8, -1, 3, -6, 1, -8, -6, -1];
//get positive negative values
var neg = res.filter(function(v) {
    return v < 0;
  }),
  // get positive values
  pos = res.filter(function(v) {
    return v > 0;
  }),
  // get zeros
  zero = res.filter(function(v) {
    return v == 0;
  });

// concat result arrays
res = neg.concat(zero, pos);

document.write(JSON.stringify(res));

＆＃13;

相同的方法，不使用任何其他变量

＆＃13;

var res = [3, 4, -6, 0, -8, -1, 3, -6, 1, -8, -6, -1];

res = res.filter(function(v) {
  return v < 0;
}).concat(res.filter(function(v) {
  return v == 0;
}), res.filter(function(v) {
  return v > 0;
}));

document.write(JSON.stringify(res));

＆＃13;

Answer 2

按数值排序时，传递给sort的函数的基本形式为

function comparator(a, b) { return func(a) - func(b); }

这里func是一个函数，它接受元素的排序，并返回要使用的排序索引。

要按“符号”排序（否定与正数），请使用Math.sign，它会给出元素的符号：

function sign_comparator(a, b) { return Math.sign(a) - Math.sign(b); }

array.sort(sign_comparator)

这将首先对负数进行排序，将正数排在最后，否则保持其顺序不变（但请参阅下面的重要说明，对于某些浏览器可能不保持顺序不变）。

 a = [3,2,-1,0,-4,3,6,-7,-6]

 a.sort(sign_comparator)

 < [-1, -4, -7, -6, 0, 3, 2, 3, 6]

Math.sign是ES6。对于不支持IE的平台，请自行编写：

function sign(x) { return x < 0 ? -1 : x > 0 ? +1 : 0; }

如果你想在语义上编写代码，定义一个泛型函数来创建一个比较器函数

function make_numeric_comparator(func) {
  return function(a, b) { return func(a) - func(b); };
}

现在您可以将您的排序写为

a.sort(make_numeric_comparator(Math.sign))

关于稳定性的重要说明

在某些情况下，正如OP所指出的那样，原始订单不始终保留。此行为称为排序的稳定性。简单来说，排序是否保留了排序函数返回0的项目对的原始顺序？事实证明，Chrome的排序不稳定，至少在某些情况下，这就是您所看到的。另一方面，FF排序稳定。有关详细信息，请参阅this SO question和此V8问题https://code.google.com/p/v8/issues/detail?id=90。当然，我们希望我们的排序在所有浏览器中都是稳定的。这是否意味着这种方法不起作用？

不，但这意味着我们必须做一个解决方法。这是一个稳定的排序函数：

function stable_sort(array, sortfunc) {
  function _sortfunc(a, b) { return sortfunc(array[a], array[b]) || a - b; }
  return array.map((e, i) => i) . sort(_sortfunc) . map(i => array[i]);
}

> stable_sort([3, 4, -6, 0, -8, -1, 3, -6, 1, -8, -6, -1], sign_comparator)
< [-6, -8, -1, -6, -8, -6, -1, 0, 3, 4, 3, 1]

这样做是创建一个并行的索引数组，从1到array.length-1，array.map((e, i) => i)。它使用一个特殊的sort函数对这些索引进行排序，这个函数调用原始的sort函数，但是 if 该函数返回0（在同一个地方排序），它强加了索引的排序。在对索引数组进行排序之后，它会使用它来查找原始数组以创建结果（使用map(i => array[i])）。

这可能工作太多，所以您可能更喜欢其他解决方案。另一方面，您可能也希望在其他上下文中进行稳定排序，因此如果您定义了stable_sort函数，则此方法仍然比使用每个符号过滤掉数字并重新组合它们更直接。 / p>

Answer 3

对于分离正数和负数的确切要求

    var t = [-1,-2,-3,5,6,1]
    var positiveArr = [];
    var negativeArr = [];
    t.forEach(function(item){
    if(item<0){
    negativeArr.push(item);
    }
    else{
    positiveArr.push(item)
    })
console.log(positiveArr) // output [5, 6, 1]
console.log(negativeArr) // output [-1, -2, -3]

使用javascript

实施例

3 个答案:

关于稳定性的重要说明