Question

在编程测试期间，我被要求编写一个Java程序来对3x3矩阵进行排序。即我给了一个矩阵（一个二维数组，比如QString FORMAT = "d/MM/yy hh:mm:ss"; QDateTime at = QDateTime::fromString("30/06/15 12:00:00", FORMAT); qDebug() << QDateTime::currentDateTime().msecsTo(at); //Current DateTIme : 30/06/15 11:51:00 OUTPUT : -3155755905986）

m[3][3]

我被要求对这个矩阵进行排序，该矩阵应该给出一个输出矩阵

2 6 1
3 5 7 
4 8 9

我所做的是将这个3x3矩阵转换为1D阵列

1 2 3  
4 5 6 
7 8 9

并对此数组执行冒泡排序，并将结果数组转换回2D数组。

我对这种方法不满意，因为我觉得这种做法非常俗气。有没有更好的方法来做到这一点。

编辑：我想删除阵列转换部分。可以使用任何排序算法，并且希望对矩阵（2D阵列）本身执行排序。

Answer 1

根据您的奇怪要求，您可以创建一个由输入矩阵支持的视图列表，并使用标准Collections.sort对其进行排序：

public static void sortMatrix(final int[][] matrix) {
    // Assuming the matrix is rectangular
    final int n = matrix.length;
    final int m = matrix[0].length;

    List<Integer> list = new AbstractList<Integer>() {
        @Override
        public Integer set(int index, Integer element) {
            return matrix[index/m][index%m] = element;
        }

        @Override
        public Integer get(int index) {
            return matrix[index/m][index%m];
        }

        @Override
        public int size() {
            return n*m;
        }
    };
    Collections.sort(list);
}

这里我们只定义我们自己的get和set方法，它们会更改相应的矩阵元素。用法示例：

int[][] matrix = {{2,6,1},{3,5,7},{4,8,9}};
sortMatrix(matrix);
System.out.println(Arrays.deepToString(matrix));

输出：

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

Answer 2

为了减少时间复杂度，您可以使用其他排序算法，例如quicksort或者radixsort（因为您只处理数字）。

将矩阵转换为数组并不是您的主要时间消耗方法，但排序是。所以优化它，然后尝试不同的方法。

修改

根据您的数据布局m[3][3]，您可以使用bucket sort（如果您使用m[1000][1000]，这可能会带来更高的性能提升。因为您已经拥有了可以排序的存储桶，这将取消首先转换它的必要性。

Answer 3

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String args[]) {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "applicationcontext.xml");
        Employee emp = (Employee) context.getBean("b1");
        emp.show();
    }
}

Answer 4

你有N个整数，将它从2D数组转换 - ＆gt; 1D阵列和1D - ＆gt;排序通常需要花费的时间超过O（N）时间，这意味着排序会占用您的时间复杂度。也就是说，您应该专注于实现更有效的排序。

尝试使用堆排序，例如时间复杂度为O（NlogN），这比冒泡排序（O（N ^ 2））快。随着您的输入变得越来越大，您将看到流程花费的时间差异很大。

Answer 5

您可以利用Streams：

public int[][] sortWithStreams(int[][] matrix) {
    return Arrays.stream(matrix)
            // Turn it into a stream of ints by streaming each row.
            .flatMapToInt(x -> Arrays.stream(x))
            // Sort it.
            .sorted()
            // Gather the now sorted stream back into a new array.
            .collect(
                    // A new matrix.
                    () -> new int[matrix.length][matrix[0].length],
                    // Consumer folds each value into the next position in an array.
                    new ObjIntConsumer<int[][]>() {
                        // Start at [0][0]
                        int x = 0, y = 0;

                        @Override
                        public void accept(int[][] t, int value) {
                            // Place it and step on.
                            t[y][x++] = value;
                            // Wrap if necessary.
                            if (x >= t[y].length) {
                                x = 0;
                                y += 1;
                            }
                        }

                    },
                    // As `sorted` cannot generate a parallel stream it is safe to ignore the combiner.
                    null);
}

public void test() {
    int[][] matrix1 = {{2, 6, 1}, {3, 5, 7}, {4, 8, 9}};
    int[][] matrix2 = {{2, 6, 1, 12}, {3, 5, 7, 10}, {4, 8, 9, 11}};
    int[][] matrix3 = {{2, 6, 1}, {3, 5, 7}, {4, 8, 9}, {1, 3, 12}};
    // Print them.
    System.out.println(Arrays.deepToString(sortWithStreams(matrix1)));
    System.out.println(Arrays.deepToString(sortWithStreams(matrix2)));
    System.out.println(Arrays.deepToString(sortWithStreams(matrix3)));//
}

对nxn矩阵进行排序（2D阵列）

5 个答案: