如何在Java中按一列对二维数组进行排序

Question

所以我想要的是这个

int[][] arr=new int[2][8];

输入：

1 1 3 1 5 3 7 1

5 2 4 8 3 7 5 2

输出：

1 1 5 3 1 7 3 1

2 2 3 4 5 5 7 8

您可以看到它按升序按第二行排序，第一行紧随其后，我该怎么做？ 请帮忙。

我试着在下面做

Arrays.sort(arr[1]);

但我认为它不起作用。 它确实按升序对第二行进行排序，但第一行与第二行的初始对不匹配

Answer 1

尝试这个。

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

    List<int[]> list = new AbstractList<int[]>() {

        @Override
        public int[] get(int index) {
            return new int[] {array[1][index], array[0][index]};
        }

        @Override
        public int[] set(int index, int[] value) {
            int[] old = get(index);
            array[1][index] = value[0];
            array[0][index] = value[1];
            return old;
        }

        @Override
        public int size() {
            return array[0].length;
        }
    };

    Collections.sort(list, Arrays::compare);

    for (int[] row : array)
        System.out.println(Arrays.toString(row));
}

输出：

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

Answer 2

可以使用辅助方法实现转置输入数组，然后转置数组可以按列排序，然后再次转置以恢复原始行/列：

// create new array to store transposed
public static int[][] transpose(int[][] src) {
    return transpose(src, new int[src[0].length][src.length]);
}    

// use existing array to store the transposed
public static int[][] transpose(int[][] src, int[][] dst) {
    for (int i = 0, n = src.length; i < n; i++) {
        for (int j = 0, m = src[i].length; j < m; j++) {
            dst[j][i] = src[i][j];
        }
    }
    return dst;
}

方法sortByColumn （重用输入数组）：

public static void sortByColumn(int[][] arr, Comparator<int[]> comparator) {
    int[][] toSort = transpose(arr);
    Arrays.sort(toSort, comparator);
    transpose(toSort, arr);
}

测试：

int[][] arr = {
    {7, 1, 3, 1, 5, 3, 1, 4, 4},
    {5, 2, 4, 8, 3, 7, 5, 2, 5}
};

sortByColumn(arr, Comparator.comparingInt(col -> col[1]));

for (int[] row : arr) {
    System.out.println(Arrays.toString(row));
}

输出：在第一行中，值按每列中的第二个元素排序后按插入顺序出现。

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

---

方形数组（宽度 == 高度）可以更有效地转置，而无需创建额外的数组：

public static int[][] transposeSquare(int[][] arr) {
    for (int i = 0, n = arr.length; i < n; i++) {
        // select the elements only above the main diagonal
        for (int j = i + 1, m = arr[i].length; j < m; j++) {
            int tmp = arr[i][j];
            arr[i][j] = arr[j][i];
            arr[j][i] = tmp;
        }
    }
    return arr;
}