用javascript分隔数组中的正负数

Separate negative and positive numbers in array with javascript

本文关键字：javascript 分隔 数组      更新时间：2023-09-26

我试着把负面&

例子:

输入数组:  [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()方法使用临时数组，但如何做到这一点，而不使用该数组中的临时数组?

使用 sort() 

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

你需要添加自定义排序条件。

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

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

相同的方法，不使用任何额外的变量

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

当按数值排序时，传递给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 sort 是稳定的。有关详细信息，请参阅此SO问题和此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)。它使用调用原始排序函数的特殊排序函数对这些索引进行排序，但是如果该函数返回0(在同一位置排序)，则强制对索引进行排序。在索引数组排序之后，然后使用它查找原始数组以创建结果(使用map(i => array[i]))。

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

满足正负数分离的精确要求

    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]
相关文章：