从最小到最大对二维整数数组的行进行排序

Question

我有一个名为 arry 的二维整数数组，如下所示：

[6, 2, 7]
[3, 6, 7]
[5, 6, 1]
[5, 3, 4]
[5, 3, 8]

我想按照结果的方式对它进行排序（为此我创建了相同大小的新数组，命名为 table）：

[3, 6, 7]
[5, 6, 1]
[5, 3, 4]
[5, 3, 8]
[6, 2, 7]

我有这个代码：

for (int k = 0; k < numOfArrays; k++) {
    int smallest = 2147483647;
    int indexSmallest = 0;
    for (int h = 0; h < numOfArrays; h++) {
        if (arry[h][0] < smallest) {
            smallest = arry[h][0];
            indexSmallest = h;
        }
    }
    tabel[k] = arry[indexSmallest];
    arry[indexSmallest][0] = 2147483647;
}

for (int k = 0; k < numOfArrays; k++) {
    System.out.println(Arrays.toString(tabel[k]));
}

结果是：

[2147483647, 6, 7]
[2147483647, 6, 1]
[2147483647, 3, 4]
[2147483647, 3, 8]
[2147483647, 2, 7]

如果我从未将 table 的任何值设置为 2147483647，我不明白 table 怎么可能包含 2147483647？

Answer 1

arry[indexSmallest][0] = 2147483647;

这行代码在最外层的 for 循环结束时将每行中的第一个元素设置为 2147483647。这就是它出现在每一行中的原因。我不确定您打算在这里做什么，但这就是您获得该值的原因。

Answer 2

您已在对象中创建此信息并实施 Comparable/Comparator:

public YourObject implements Comparable {
    private long a;
    private long b;
    private long c;

    public YourObject (long a, long b, long c){
         this.a = a;
         this.b = b;
         this.c = c;
    }

    public int compareTo(Object arg0) {
        //make your comparison here...
    }

}

在主函数中：你的对象[] arr = 新的你的对象[3]; arr[0] = new YourObject (.., .., ..,); arr[1] = new YourObject (.., .., ..,); arr[2] = new YourObject (.., .., ..,);

Arrays.sort(arr); //排序你的数据

Answer 3

真正的问题是这一行：

tabel[k] = arry[indexSmallest];

记住，数组是对象。此行不复制内部数组，而是设置对它的引用。

所以此时tabel[k]和arry[indexSmallest]都指向同一个数组对象。所以当你这样做时：

arry[indexSmallest][0] = 2147483647;

您为 arry[indexSmallest] 和 tabel[k] 更改它（因为它们指向同一个对象）

要解决此问题，请分配给 tabel[k] 数组的 copy：

tabel[k] = Arrays.copyOf(arry[indexSmallest], 3);

Answer 4

记住，Java数组是对象，这意味着它们是通过引用传递的。所以你实际上并没有复制内部数组；为此使用 Arrays.copyOf()。

如果允许您将 Arrays.sort() 与 Comparator 一起使用，您可以这样做。

java.util.Arrays.sort(arry, new java.util.Comparator<int[]>() {
    public int compare(int[] a1, int[] a2) {
        for (int k = 0; k < a1.length; k++) {
            if (a1[k] != a2[k]) {
                return a1[k] - a2[k];
            }
        }
        return 0;
    }
});
for (int k = 0; k < numOfArrays; k++) {
    System.out.println(java.util.Arrays.toString(arry[k]));
}

如果不允许，那么您仍然可以使用上述 Comparator.compare() 方法中的比较逻辑。这是您的基本排序逻辑，与实现细节无关。

Answer 5

_{您可以使用 Arrays.sort 方法大大简化您的代码，或者您可以实现类似这样的东西。}

按列对二维数组进行选择排序

public static void selectionSort2D(int[][] arr, int column) {
    // iterate over all subsets of the rows of the array
    // (0-last, 1-last, 2-last, 3-last, ...)
    for (int i = 0; i < arr.length; i++) {
        // assume the min is the first row element
        int min = arr[i][column];
        // row index of the min element
        int min_i = i;
        // check the rows after i to find the smallest
        for (int j = i + 1; j < arr.length; j++) {
            // if this row element is less,
            // then it is the new min
            if (arr[j][column] < min) {
                min = arr[j][column];
                min_i = j;
            }
        }
        // if the min element row is not equal to
        // the current one, then swap these rows
        if (i != min_i) {
            int[] temp = arr[i];
            arr[i] = arr[min_i];
            arr[min_i] = temp;
        }
    }
}

// test
public static void main(String[] args) {
    int[][] arr = {
            {6, 2, 7},
            {3, 6, 7},
            {5, 6, 1},
            {5, 3, 4},
            {5, 3, 8}};

    // sort by first column
    selectionSort2D(arr, 0);

    // output
    for (int[] row : arr)
        System.out.println(Arrays.toString(row));
    //[3, 6, 7]
    //[5, 6, 1]
    //[5, 3, 4]
    //[5, 3, 8]
    //[6, 2, 7]
}

从最小到最大对二维整数数组的行进行排序

Sorting rows of a 2d integer array from smallest to biggest

java

arrays

sorting

multidimensional-array

按列对二维数组进行选择排序