Question

我被设置为一个挑战，并被告知要在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[] mergeMatrix(int[][] matrix) {
    int length = matrix.length;
    int [] sortedMatrixArray = new int[length * length];
    int loop = 0;
    for (int[] i : matrix) {
        for (int j = 0; j < length; j++) {
            if (loop == 0) {
                sortedMatrixArray[j] = i[j];
            }
            sortedMatrixArray[j + (length*loop)] = i[j];
        }
        loop++;
    }
    insertionSort(sortedMatrixArray);
    return sortedMatrixArray;
}

Answer 1

如果n是矩阵的大小，则矩阵具有n^2个元素。

您的insertionSort将n^2元素作为输入。它可以工作O(k^2)（其中k是输入端口），因此您总共拥有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;
    }
}

使用一些高级数据结构可以将该算法从O(n^3)改进为O(n^2*log(n))，从而可以更快地找到具有最小当前元素的行（某种树）。

Answer 2

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

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

2 个答案: