Java 这个算法是O（n^2）吗？

我被设置了一个挑战，并被告知在O（n^3）中解决它，因为显然在O（n^2）中是不可能的，O（n^2）是最初的任务，但它被更改了。挑战在于编写一个算法，遍历n*n矩阵的每一行，然后将整个矩阵作为排序数组打印。矩阵的每一行都已排序

这是我所拥有的，我认为它是O（n^2），但我仍然在正确地学习big-O，所以我想确认一下我是否做到了。它使用插入排序实用程序方法对数组进行排序。谢谢

public int[] mergeMatrix(int[][] matrix) {
    int length = matrix.length;
    int [] sortedMatrixArray = new int[length * length];
    int loop = 1;
    for (int[] i : matrix) {
        for (int j = 0; j < length; j++) {
            switch (loop) {
                case 1:
                    sortedMatrixArray[j] = i[j];
                    break;
                case 2:
                    sortedMatrixArray[j + 3] = i[j];
                    break;
                case 3:
                    sortedMatrixArray[j + 6] = i[j];
                    break;
            }
        }
        loop++;
    }
    insertionSort(sortedMatrixArray);
    return sortedMatrixArray;
}

private void insertionSort(int[] array) {
    for (int firstUnsortedIndex = 0; firstUnsortedIndex < array.length; firstUnsortedIndex++) {
        int newElement = array[firstUnsortedIndex];
        int i;
        for (i = firstUnsortedIndex; i > 0 && array[i-1] > newElement; i--) {
            array[i] = array[i-1];
        }
        array[i] = newElement;
    }
}

public int[]合并矩阵（int[]矩阵）{
int length=矩阵长度；
int[]sortedMatrix阵列=新int[length*length]；
int循环=1；
for（int[]i:矩阵）{
对于（int j=0；j0&&array[i-1]>newElement；i--）{
数组[i]=数组[i-1]；
}
数组[i]=新元素；
}
}

编辑：

public int[]合并矩阵（int[]矩阵）{
int length=矩阵长度；
int[]sortedMatrix阵列=新int[length*length]；
int循环=0；
for（int[]i:矩阵）{
对于（int j=0；j

你说得对，它是O（n^2）。insertionSort也是O（n^2），但由于您是在前两个for循环完成后调用它，因此您的运行时间是

---

O（n^2）+O（n^2）=O（n^2）

如果

n

是矩阵的大小，那么矩阵有

n^2

元素

您的

insertionSort

将

n^2

元素作为输入。它的作用是

O（k^2）

（其中

k

是输入的sze），所以你总共有

O（n^2^2）

，也就是

O（n^4）

要使其

O（n^3）

可以执行以下操作

public class App {
    public static void main(String[] args) {
        int[] result = sort(new int[][]{{1, 4, 7}, {2, 5, 8}, {3, 6, 9}});

        System.out.println("result = " + Arrays.toString(result));
    }

    static int[] sort(int[][] matrix) {
        int total = 0;
        for (int i = 0; i < matrix.length; i++) {
            total += matrix[i].length;
        }

        // indexes variable store current position for each row.
        int[] indexes = new int[matrix.length];
        int[] result = new int[total];
        for (int i = 0; i < total; i++) {
            int minIndex = 0;
            int minValue = Integer.MAX_VALUE;
            // this loop search for row with minimal current position.
            for (int j = 0; j < matrix.length; j++) {
                //Ignore row which are exhausted
                if (indexes[j] >= matrix[j].length) {
                    continue;
                }
                if (matrix[j][indexes[j]] <= minValue) {
                    minIndex = j;
                    minValue = matrix[j][indexes[j]];
                }
            }
            result[i] = matrix[minIndex][indexes[minIndex]];
            indexes[minIndex]++;
        }

        return result;
    }
}

公共类应用程序{
公共静态void main（字符串[]args）{
int[]result=sort（新的int[][{{1,4,7}，{2,5,8}，{3,6,9}）；
System.out.println（“result=“+Arrays.toString（result））；
}
静态int[]排序（int[][]矩阵）{
int-total=0；
对于（int i=0；i=矩阵[j].长度）{
继续；
}
if（矩阵[j][索引[j]]如果您询问代码是否为O（n^2），那么是的。但是你确定给出了正确的结果吗？
开关
块和
循环
变量似乎表明它只适用于特殊情况，尽管我可能会弄错。嗨，我在不同大小的多个2D数组上测试过它，每次都会给出一个排序数组。你有什么特殊情况是吗？只是我不明白j+3和j+6的意义，也不存在循环>3的情况，所以它什么都不做（只是不必要地旋转）在处理了第一个嵌套循环中的前三行之后…但是我很累，可能没有正确地阅读代码。如果您使用大量随机生成的输入矩阵对其进行了测试并验证了结果，那么它可能是正确的。但是您确定您的测试代码是正确的吗？：-d感谢您指出这一点，我有在我的测试中错误地输入了相同的数组，并认为它是正确的，而不是正确的。我重新编写了它，并在原始代码下面重新发布了它。谢谢！！这更有意义！对于
循环==0的特殊情况，你甚至可以省略
if
语句，因为j+（长度*0）=j.现在我也明白了你在做什么：你用矩阵中的所有元素创建一个一维数组，然后使用标准排序算法对数组进行排序。
n
是矩阵的大小。矩阵有
n^2
元素。插入排序对整个矩阵有效，因此它有
O（n^2^2）
complexity。插入排序只在SortedMatrix数组上迭代，而不是矩阵
SortedMatrix数组
have
n^2
大小。非常感谢！我不想怀疑你，但这里还有两个人说我的算法是O（n^2），我怎么知道你们谁是对的呢？我想对于big-O，你只需要使用最坏的情况，所以将矩阵转换成数组需要O（n^2），插入排序需要O（n^2），这难道不意味着最坏的情况是O（n^2）吗？谢谢你说“插入排序需要
O（n^2）
”您应该考虑到这是不同的
n
这个新的
n
是
sortedMatrixArray
的大小，就原始
n
而言，它是
n^2
public class App {
    public static void main(String[] args) {
        int[] result = sort(new int[][]{{1, 4, 7}, {2, 5, 8}, {3, 6, 9}});

        System.out.println("result = " + Arrays.toString(result));
    }

    static int[] sort(int[][] matrix) {
        int total = 0;
        for (int i = 0; i < matrix.length; i++) {
            total += matrix[i].length;
        }

        // indexes variable store current position for each row.
        int[] indexes = new int[matrix.length];
        int[] result = new int[total];
        for (int i = 0; i < total; i++) {
            int minIndex = 0;
            int minValue = Integer.MAX_VALUE;
            // this loop search for row with minimal current position.
            for (int j = 0; j < matrix.length; j++) {
                //Ignore row which are exhausted
                if (indexes[j] >= matrix[j].length) {
                    continue;
                }
                if (matrix[j][indexes[j]] <= minValue) {
                    minIndex = j;
                    minValue = matrix[j][indexes[j]];
                }
            }
            result[i] = matrix[minIndex][indexes[minIndex]];
            indexes[minIndex]++;
        }

        return result;
    }
}