按降序对数字进行排序，但以 `0` 开头

Question

我在 JavaScript 中遇到了一个挑战，我已经尝试解决了一段时间。

考虑这个数组：

let arr = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];

我必须输出这个结果：

arr = [0, 0, 0, 0, 0, 5, 4, 3, 2, 1]

我是按照这行逻辑把零放在前面，调整索引值：

arr.sort((x, y) => {
    if (x !== 0) {
        return 1;
    }

    if (x === 0) {
        return -1;
    }

    return y - x;
});

但我被这个结果卡住了：

arr = [0, 0, 0, 0, 0, 1, 2, 3, 4, 5]

谁有解决这个问题的建议？

Answer 1

您可以按b 和a 的增量排序（用于降序排序）并采用Number.MAX_VALUE，用于零等虚假值。

这个：

Number.MAX_VALUE - Number.MAX_VALUE

等于零。

let array = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];

array.sort((a, b) => (b || Number.MAX_VALUE) - (a || Number.MAX_VALUE));

console.log(...array);

Answer 2

As mdn docs says:

如果a和b是两个被比较的元素，那么：

如果compareFunction(a, b) 返回小于0，则将a 排序到下一个索引 比 b （即 a 先出现）。

如果compareFunction(a, b) 返回 0，则离开 a 和 b 相对于彼此保持不变，但按照尊重排序 到所有不同的元素。注意：ECMAscript 标准没有 保证这种行为，因此，并非所有浏览器（例如 Mozilla 版本 至少可以追溯到 2003 年）尊重这一点。

如果compareFunction(a, b) 返回大于 0，将 b 排序到低于 a 的索引（即 b 来 第一的）。

compareFunction(a, b) 必须始终返回相同的值 给定一对特定的元素 a 和 b 作为它的两个参数。如果 返回不一致的结果，则排序顺序未定义。

所以，比较函数的形式如下：

function compare(a, b) {
  if (a is less than b by some ordering criterion) {
    return -1;
  }
  if (a is greater than b by the ordering criterion) {
    return 1;
  }
  // a must be equal to b
  return 0;
}

let arr = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];

arr.sort((x, y) => {
    if (x > 0 && y > 0) {
        return y - x;
    }
    return x - y;
});

console.log(arr);

Answer 3

如果您关心效率，首先过滤掉零可能是最快的。您不希望 sort 浪费时间甚至查看它们，更不用说在比较回调中添加额外的工作来处理这种特殊情况。

特别是如果您预计会有大量的零，则通过一次数据过滤以将它们过滤掉应该比进行多次查看每个零的更大的 O(N log N) 排序要好得多。

您可以在完成后efficiently 在前面加上正确数量的零。

生成的代码也很容易阅读。我使用 TypedArray 是因为它高效且 makes numeric sorting easy。但是您可以将此技术与常规 Array 一起使用，使用 (a,b)=>a-b 的标准习语来表示 .sort。

let arr = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];

let nonzero_arr = Int32Array.from(arr.filter(n => n != 0));
let zcount = arr.length - nonzero_arr.length;
nonzero_arr.sort();      // numeric TypedArray sorts numerically, not alphabetically

// Reverse the sorted part before copying into the final array.
nonzero_arr.reverse();

 // efficient-ish TypedArray for main result
let revsorted = new Int32Array(arr.length);   // zero-filled full size
revsorted.set(nonzero_arr, zcount);           // copy after the right number of zeros

console.log(Array.from(revsorted));      // prints strangely for TypedArray, with invented "0", "1" keys

/*
   // regular Array result
let sorted = [...Array(zcount).fill(0), ...nonzero_arr]  // IDK if this is efficient
console.log(sorted);
*/

我不知道 TypedArray .sort() 然后.reverse 是否比使用自定义比较函数按降序排序更快。或者，如果我们可以使用迭代器即时复制和反转。

---

同样值得考虑：只使用一个全长的 TypedArray。

不要使用.filter，而是循环它，然后交换零到数组的前面。这需要对您的数据进行一次传递。

然后使用.subarray() 获取相同底层ArrayBuffer 的非零元素的新TypedArray 视图。排序将使您的整个数组具有零开始和排序的尾，排序只查看非零元素。

我没有在 Array 或 TypedArray 方法中看到分区函数，但我几乎不了解 JavaScript。使用良好的 JIT，循环不应该比内置方法差太多。 （特别是当该方法涉及像.filter 这样的回调时，除非它在后台使用realloc 进行收缩，否则它必须在实际过滤之前确定要分配多少内存。

我在转换为 TypedArray 之前使用了常规数组 .filter()。如果您的输入已经是 TypedArray，您就不会有这个问题，而且这种策略会变得更有吸引力。

Answer 4

只需像这样修改比较函数的条件 -

let arr = [-1, 0, 1, 0, 2, -2, 0, 3, -3, 0, 4, -4, 0, 5, -5];
arr.sort((a, b) => {
   if(a && b) return b-a;
   if(!a && !b) return 0;
   return !a ? -1 : 1;
});

console.log(arr);

Answer 5

这里不打代码高尔夫：

let arr = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5, -1];
arr.sort(function(a, b) {
  if (a === 0 && b !== 0) {
    // a is zero b is nonzero, a goes first
    return -1;
  } else if (a !== 0 && b === 0) {
    // a is nonzero b is zero, b goes first
    return 1;
  } else {
    // both are zero or both are nonzero, sort descending
    return b - a;
  }
});
console.log(arr.toString());

Answer 6

如果已经存在，请不要编写自己的数字排序。你想做的正是你在标题中所说的；除开头的零外，按降序对数字进行排序。

const zeroSort = arr => [...arr.filter(n => n == 0),
                         ...new Float64Array(arr.filter(n => n != 0)).sort().reverse()];

console.log(zeroSort([0, 1, 0, 2, 0, 3, 0, 4, 0, 500]));

不要编写任何你不需要的代码；你可能会弄错。

根据您希望数组处理的数字类型选择TypedArray。 Float64 是一个很好的默认值，因为它可以处理所有普通的 JS 数字。

Answer 7

你可以这样做：

let arr = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];

let result = arr.sort((a,b) => {
  if(a == 0 || b == 0)
    return a-b;
  return b-a;
})
console.log(result)

或者你可以这样做：

let arr = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];

let result = arr.sort().sort((a,b) => {
  if(a > 0 && b > 0)
    return b-a
  return 0
})

console.log(result)

Answer 8

上面的大多数答案都不是按照现实生活场景进行优化的：

1. 并非总是要过滤掉 0。所以所有使用 Only Sort 功能的答案对我来说都不够好
2. 输入并不总是整数，而是在排序期间要比较的字符串甚至对象。所以使用 TypedArray 进行排序和反向的答案还不够好

我更喜欢以下内容

function customSort( source, target )  { target - source } // a custom sorting depending on business logic required

function sortAndFilter(inputArray, candidateValue) { // a Candidate Value to be filtered out

// step 1: use optimized custom sort (think Merge Sort) to sort all items. You would like to pass candidateValue(s) to be Not considered for sorting and move them to separate list or at beginning/end of the array depending on business logic

const reversedArray = inputArray.sort( customSort);

// step 2: merge the sorted list(s) with custom logic. in this case its just moving the candidateValue to front and removing from elsewhere so following is good enough
reversedArray.forEach( (item, index) => {
    if (item === candidateValue) {
        reversedArray.splice(index, 1)
        reversedArray.unshift(item)
    }
});
return reversedArray
}

console.log(sortAndFilter(arr,0))

Answer 9

const myArray = [0, 1, 0, 2, 0, 3, 0, 4, 0, 5];
const splitArray = myArray.reduce((output, item) => {
     if(!item) output[0].push(item);
    else output[1].push(item);
    return output;
}, [[], []]);
const result = [...splitArray[0], ...splitArray[1].reverse()]
console.log(result);