Question

我正在寻找最好的算法来旋转2D数组/矩阵中的一行。假设我们有

mat[3][3] = {{1,2,3},{4,5,6},{7,8,9}};

我想将元素向左移动一个，第一行1 2 3将变为2 3 1。该功能通过动态内存分配将每个元素复制到左侧来实现。

void rotate_row(const int& row) {

    int *temp_row = (int *) (malloc(3));
    for (int i = 0; i < 3; ++i) {
        temp_row[i % 3] = mat[row][(i + 1) % 3];

    }

    memcpy(mat[row], temp_row, 3);
    free(temp_row);
}

要操作任何特定的行，我们只需调用函数rotate_row(row)。

由于我从小学习一种全新的动态分配方式，所以我不太了解C中的malloc内容，因此我首先将其更改为：

void rotate_rows(const int& row) {
    //int *temp_row = (int *) (malloc(3));
    int *temp_row = new int[3];
    for (int i = 0; i < 3; ++i) {
        temp_row[i % 3] = mat[row][(i + 1) % 3];

    }
    memcpy( mat[row], temp_row, 3);
    //free(temp_row);
    delete [] temp_row;
    temp_row = NULL;
}

首先我的问题是，简单地改变动态内存分配方式会加速代码吗？

此外，我认为没有必要为我的目的使用动态内存分配（旋转行）。有没有更好（不一定是最好的）算法？

Answer 1

旋转不会更改数组大小，因此就地执行此操作对我来说性能更高，无需动态分配内存并释放先前的指针。

void rotate(int * array, size_t n) {
    if (n <= 1)
        return;

    const int head = array[0];

    for (size_t i = 1; i < n; ++i)
        array[i - 1] = array[i];
    array[n - 1] = head;
}

Answer 2

您可以避免所有动态内存分配，而使用std::rotate算法：

#include <algorithm>
#include <iostream>

int main()
{
    int mat[3][3] = { {1,2,3},{4,5,6},{7,8,9} };

    // rotate left each row by 1
    for (int i = 0; i < 3; ++i)
        std::rotate(&mat[i][0], &mat[i][1], &mat[i][3]);

    for (int i = 0; i < 3; ++i)
        std::cout << mat[i][0] << " " << mat[i][1] << " " << mat[i][2] << "\n";
}

输出：

2 3 1
5 6 4
8 9 7

编辑：

以下是按行索引+ 1旋转每行的示例：

#include <algorithm>
#include <iostream>

int main()
{
    int mat[3][3] = { {1,2,3},{4,5,6},{7,8,9} };

    // rotate left each row by 1
    for (int i = 0; i < 3; ++i)
        std::rotate(&mat[i][0], &mat[i][i+1], &mat[i][3]);

    for (int i = 0; i < 3; ++i)
        std::cout << mat[i][0] << " " << mat[i][1] << " " << mat[i][2] << "\n";
}

输出：

2 3 1
6 4 5
7 8 9

Answer 3

是的，有更好的方法，不需要使用动态内存分配。您实际上不需要其他数组即可解决此问题。这是示例代码：

1:231

这很简单，因此我认为您无需解释即可轻松理解代码。

旋转二维数组的最快方法

3 个答案: