javascript排序二维数组在我的数组中重复

Question

我正在尝试根据第 3 列对我的二维数组进行排序。当我使用 sort 函数对其进行排序时，所有数组成员都成为原始数组中一个成员的副本。

例如;

我的原始数组:

[12, AAA, eee, 5]
[58, BBB, zzz, 3]
[28, CCC, ddd, 6]
[18, DDD, fff, 9]

我希望它变成:

[18, DDD, fff, 9]
[28, CCC, ddd, 6]
[12, AAA, eee, 5]
[58, BBB, zzz, 3]

我使用代码:

function sortByColumn(a, colIndex){

    a.sort(sortFunctionq);

    function sortFunctionq(a, b) {
        if (a[colIndex] === b[colIndex]) {
            return 0;
        }
        else {
            return (a[colIndex] > b[colIndex]) ? -1 : 1;
        }
    }

    return a;
}

var sorted_a = new Array(15);
sorted_a = sortByColumn(arr, 3);

现在数组变为:

[18, DDD, fff, 9]
[18, DDD, fff, 9]
[18, DDD, fff, 9]
[18, DDD, fff, 9]

我在 Samsung Gear watch 上使用 javascript。也许它不正确支持“排序”功能。有没有一种方法可以在不使用排序函数的情况下对二维数组进行排序？

---

最终代码为:

    var sorted_a = new Array(15);
    sorted_a = sortByColumn(arrx, 3);
    arrx= sorted_a;

function bubbleSort(a, fCompare) {
    if( a.length < 2)   {return a;}
    for( var length = a.length-1; length; --length) {
        var noSwaps = true;
        var temp;
        for(var c=0; c<length; ++c) {
            if( fCompare( a[c], a[c+1]) > 0) {
                temp = a[c+1];
                a[c+1] = a[c];
                a[c] = temp;
                noSwaps = false;
            }
        }
        if( noSwaps) {break;}
    }
}

function sortByColumn(a, colIndex){
    function sortFunctionq(a, b) {
        if (a[colIndex] === b[colIndex]) {
            return 0;
        }
        else {
            return (a[colIndex] > b[colIndex]) ? -1 : 1;
        }
    }
    //return bubbleSort(a, sortFunctionq);
    return bubbleSort(a.slice(), sortFunctionq);
}

但现在数组中没有可用的内容。

对于那些问:如果我删除排序函数并按原样使用 arrx，我可以使用 arrx[1][1] 到达二维数组元素但是上面的代码 arrx[1][1] 返回 null。

---

我稍微修改了一下，现在它似乎可以工作了。但现在我也需要删除重复项。我该怎么做？

当前代码:

    var arrx = new Array(50);
    for (var j = 0; j<50; j++){
        arrx[j] = arr[j].split("|+");
    }
    var arry = new Array(50);
    arry = bubbleSort(arrx);

function bubbleSort(a) {
    for( var r = 49; r >= 0; --r) {
        var noSwaps = true;
        var temp = new Array(50);
        for(var c=0; c<r; ++c) {
            if (a[c][3] < a[c+1][3]) {
                temp = a[c+1];
                a[c+1] = a[c];
                a[c] = temp;
                noSwaps = false;
            }
        }
        if( noSwaps) {break;}
    }
    return a;
}

Answer 1

您问题的直接答案是“是的，可以在不使用数组的排序方法的情况下对数组进行排序”。使用冒泡排序的简单示例:

function bubbleSort(a, fCompare) {
    if( a.length < 2)
        return a;
    for( var length = a.length-1; length; --length) {
        var noSwaps = true;
        var temp;
        for( i=0; i<length; ++i) {
            if( fCompare( a[i], a[i+1]) > 0) {
                temp = a[i+1];
                a[i+1] = a[i];
                a[i] = temp;
                noSwaps = false;
            }
        }
        if( noSwaps)
            break;
    }
}

function sortByColumn(a, colIndex){
    function sortFunctionq(a, b) {
        if (a[colIndex] === b[colIndex]) {
            return 0;
        }
        else {
            return (a[colIndex] > b[colIndex]) ? -1 : 1;
        }
    }
    return bubbleSort(a, sortFunctionq);
}
var a = [
   [12, 'AAA', 'eee', 5],
   [58, 'BBB', 'zzz', 3],
   [28, 'CCC', 'ddd', 6],
   [18, 'DDD', 'fff', 9],
];
 
var sortedA = sortByColumn(a,2)  // updates a in-place, as well
console.log( JSON.stringify(sortedA))

然而

请注意，数组的 sort 方法和上面的 bubbleSort 都会更改正在排序的数组中元素的顺序，而不会创建数组的浅拷贝。虽然 bubbleSort 可能显示 Samsung JS 引擎有问题，但它很可能不会产生相同的结果。

因为排序是对数组进行就地排序，所以您可能希望在排序之前检查创建它的浅拷贝是否可以解决问题。 EG通过将示例中的return语句替换为

return a.slice().sort(functionq) // OR
return bubbleSort(a.slice(), functionq)

---

调试说明:

1. JavaScript 数组是对象。对象变量的值是 JavaScript 引擎用来访问对象属性的某种引用。该引用可以是内存指针或引擎用来访问对象数据的其他一些值。当您将对象分配给变量时，其现有内容将被覆盖。如果将相同的对象值分配给两个变量，它们将持有相同的引用值并引用同一组对象数据。

   var arry = new Array(50);
   arry = bubbleSort(arrx);
   

   不必要地创建一个新的数组，因为新的数组值在第二行被覆盖了。可以简化为

   var arry = bubbleSort( arrx).
   

   请注意，JavaScript 数组可以增长和收缩，并且没有预先分配的长度。

2. 冒泡排序代码和内置数组 sort 方法(由 Array.prototype 对象的数组实例继承，并在 MDN 上记录在 Array.prototype.sort 下) 就地对数组进行排序，并返回对正在排序的数组的对象引用。之后

   arry = bubbleSort(arrx);  // OR
   arry = arrx.sort(sortFunction)
   

   arry 的值与 arrx 相同。 如果您想复制一个不受 arrx 第一维值的修改，在排序之前制作输入数组的浅拷贝:

   arry = bubbleSort(arrx.slice());
   

   如果您想制作一个不受任何维度值修改影响的副本，则制作两个维度数组的浅拷贝，例如:

   arry = bubbleSort( arrx.map(element => element.slice())
   

   这会在排序前从 arrx 的两个维度创建新数组。

如果在此之后您仍然收到重复的条目，您将需要找出代码中分配重复项的位置。

---

提示

检查使用 =(赋值运算符)而不是 == 或 === 运算符的条件测试中没有拼写错误平等性测试。这是一种无意中将值分配给不打算更改的内容的好方法。