如何覆盖 JavaScript 数组排序方法？

Question

截至 10 月 31 日星期一，此问题仍未得到更正 （人们错误地回答它，好像我要求修改 array.sort 但我没有问这个）

如何使用 radix-msd 算法覆盖 single 数组（不是 Array.sort）的内置 JavaScript 排序方法？

我有基数 msd 排序的算法，它是

// radix most-significant-bit sort for integers
//arr: array to be sorted
//begin: 0
//end: length of array
//bit: maximum number of bits required to represent numbers in arr
function radixsort (arr, begin, end, bit) {
    var i, j, mask;
    i = begin;
    j = end;
    mask = 1 << bit;
    while(i < j) {
        while(i < j && !(arr[i] & mask)) {
            ++i;
        }
        while(i < j && (arr[j - 1] & mask)) {
            --j;
        }
        if(i < j) {
            j--;
            var tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
        }
    }
    if(bit && i > begin) {
        radixsort(arr, begin, i, bit - 1);   //    <=== RECURSIVE FUNCTION
    }
    if(bit && i < end) {
        radixsort(arr, i, end, bit - 1);     //    <=== RECURSIVE FUNCTION
    }
}

而我的 JavaScript 对象数组是：

homes[0].price;
homes[0].address;
homes[0].city;
homes[0].state;
homes[0].zip;

因此，当我调用“homes.sort()”时 - 我希望它使用上面的 radix sort 数组根据 price 对整个 homes[x] 数组进行排序。 我该怎么做？

Answer 1

您无需覆盖sort function，只需将比较器函数作为参数传递给sort 方法即可。

参数的函数签名是function (a, b)，其中a 是与b 进行比较的项目。

如果您需要不同的排序实现，请将其设置为不同的函数，而不是覆盖默认行为。您可以使用以下方法对所有数组执行此操作：

Array.prototype.radixsort = function ( ...params... )

这将允许您调用

[1,2,3].radixsort(...params...);

或者，您可以向Array 添加一个实用函数：

Array.radixsort = function ( ...params... )

这将被称为：

Array.radixsort([1,2,3], ...params...);

Answer 2

我认为修改Array.prototype.sort 是非常危险的（因为所有其他可能使用 sort() 的代码都会受到影响）。这是代码：

//Just use this function like radixsort(homes,0,homes.length,32)
function radixsort (arr, begin, end, bit) {
    var i, j, mask;
    i = begin;
    j = end;
    mask = 1 << bit;
    while(i < j) {
        while(i < j && !(arr[i].price & mask)) {
            ++i;
        }
        while(i < j && (arr[j - 1].price & mask)) {
            --j;
        }
        if(i < j) {
            j--;
            var tmp = arr[i].price;
            arr[i].price = arr[j].price;
            arr[j].price = tmp;
            i++;
        }
    }
    if(bit && i > begin) {
        radixsort(arr, begin, i, bit - 1);
    }
    if(bit && i < end) {
        radixsort(arr, i, end, bit - 1);
    }
}
//If you really want to modify default sort function:
Array.prototype.sort = function(){
    radixsort(this,0,this.length,32); //Use 'this' to access (get reference) to the array.
}

Answer 3

扩展 Ray Toal 和 zzzzBov 的讨论：

  function defaultCompare(a, b) {
      var a_str = str(a);
      var b_str = str(b);
      if (a_str < b_str) {
          return -1;
      } else if (a_str > b_str) {
          return 1;
      } else {
          return 0;
      }
   }

   homes.sort = function (compare_func) {
       compare_func = compare_func || defaultCompare;
       RadixSort(this, 0, this.length, 64);
   }

上面可能有错别字，但应该是朝着更完整的实现迈出的一步。

Answer 4

你的问题是问两件事：

1. 如何在数组上调用sort，但调用Array.sort以外的函数？
2. 如何让排序算法使用特定字段而不对其进行硬编码？

第一个问题的答案是在homes对象本身上附加一个sort方法：

homes.sort = function () {radixSort(homes, 0, homes.length, bit);}

正如其中一位评论者和其他回答者所指出的那样，这样做可能会非常令人困惑。一方面，Arrays.sort 采用第二个参数，它是一个比较函数。基数排序是基于分布的排序，而不是基于比较的排序，因此以这种方式“覆盖”sort 没有多大意义。如果有人将比较函数传入，您将忽略它。

但是还有另一个问题。您所写的radixSort 不起作用，因为它不比较价格。答案之一是硬编码价格，但您说您不喜欢这种情况。您可以按如下方式解决此问题：添加第五个参数，即字段名称。如果未定义，则使用数组元素本身，否则选择字段。像这样的东西（未测试）：

function radixsort (arr, begin, end, bit, field) {
    var i = begin, j = end , mask = 1 << bit;
    // Use the value of the field at i if present, otherwise the whole element
    var at = function (i) {return field in arr ? arr[i][field] : arr[i]};
    while (i < j) {
        while (i < j && !(arr.at(i) & mask)) {
            ++i;
        }
        while (i < j && (arr.at(j-1) & mask)) {
            --j;
        }
        if (i < j) {
            j--;
            var tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
        }
    }
    if (bit && i > begin) {
        radixsort(arr, begin, i, bit - 1);
    }
    if (bit && i < end) {
        radixsort(arr, i, end, bit - 1);
    }
}

现在你可以说：

homes.sort = function () {radixSort(homes, 0, homes.length, 64, 'price');}

但是，请记住以下警告：

CAVEAT：如果price 是浮点值，则基数排序可能不起作用。最好的办法是只使用 Array.prototype.sort 并传入一个比较器以对不同的字段进行排序。