C++程序 将矩阵旋转180度

给定一个方阵，任务是将其逆时针旋转180度，不使用额外的空间。

示例 :

输入 : 1 2 3
       4 5 6
       7 8 9
输出 : 9 8 7 
       6 5 4 
       3 2 1

输入 : 1 2 3 4 
       5 6 7 8 
       9 0 1 2 
       3 4 5 6 
输出 : 6 5 4 3 
       2 1 0 9 
       8 7 6 5 
       4 3 2 1

方法1（仅打印旋转的矩阵）

解决此问题的方法是将矩阵旋转180度，我们可以轻松地遵循此步骤

Matrix = a00 a01 a02
        a10 a11 a12
        a20 a21 a22

当我们将其旋转90度时
那么矩阵就是
Matrix = a02 a12 a22
          a01 a11 a21
          a00 a10 a20

当我们再旋转90度时
那么矩阵就是
Matrix = a22 a21 a20
          a12 a11 a10
          a02 a01 a00

从上面的示例中， 我们得出的结论是，仅需将给定的矩阵以相反的方式打印即可将矩阵旋转180度。

// C++程序：将矩阵旋转180度
# include <bits/stdc++.h>
# define N 3
using namespace std;
  
// 旋转矩阵180度的函数
void rotateMatrix(int mat[][N])
{
  // 从最后一个单元格简单地打印即可。
  for (int i = N - 1; i >= 0; i--) {
    for (int j = N - 1; j >= 0; j--)
      printf("%d ", mat[i][j]);

    printf("
");
  }
}
  
// 主函数入口
int main()
{
  int mat[N][N] = {
    { 1, 2, 3 },
    { 4, 5, 6 },
    { 7, 8, 9 }
  };

  rotateMatrix(mat);
  return 0;
}  

输出 :

 9 8 7 
 6 5 4 
 3 2 1  

时间复杂度: O(N * N)

辅助空间: O(1)

方法2（原地旋转）

有四个步骤：

1- 找到矩阵的转置。

2- 反转转置的每一列。

3- 再找到矩阵的转置。

4- 再反转转置的每一列。

假设给定矩阵为
1  2  3  4
5  6  7  8
9  10 11 12
1314 15 16

首先我们找到转置。
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16

然后我们反转每一列的元素。
4 8 12 16
3 7 11 15
2 6 10 14
1 5  9 13

然后再次找到转置。
4 3 2 1 
8 7 6 5 
12 11 10 9
16 15 14 13 

然后我们再次反转每一列的元素。
16 15 14 13 
12 11 10 9 
8 7 6 5 
4 3 2 1

// C++程序，用于将矩阵左旋转180度
# include
using namespace std;

# define R 4
# define C 4

// 将矩阵的列反转
void reverseColumns(int arr[R][C])
{
    for (int i = 0; i < C; i++)
        for (int j = 0, k = C - 1; j < k; j++, k--)
            swap(arr[j][i], arr[k][i]);
}

// 矩阵的转置
void transpose(int arr[R][C])
{
    for (int i = 0; i < R; i++)
        for (int j = i; j < C; j++)
            swap(arr[i][j], arr[j][i]);
}

// 显示矩阵
void printMatrix(int arr[R][C])
{
    for (int i = 0; i < R; i++) {
        for (int j = 0; j < C; j++)
            cout << arr[i][j] << " ";
        cout << '\n';
    }
}

// 将矩阵逆时针旋转180度
void rotate180(int arr[R][C])
{
    transpose(arr);
    reverseColumns(arr);
    transpose(arr);
    reverseColumns(arr);
}

// 主函数
int main()
{
    int arr[R][C] = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
    rotate180(arr);
    printMatrix(arr);
    return 0;
}  

输出:

 16 15 14 13 
 12 11 10 9 
 8 7 6 5 
 4 3 2 1

时间复杂度： O(R*C)

辅助空间： O(1)

在上面的代码中，必须两次找到矩阵的转置，还必须两次反转列。

因此，我们可以有一个更好的解决方案。

方法：3（位置交换）

在这里，我们交换相应位置的值。

# include
using namespace std;

/**
 * 反转矩阵中指定索引处的行
 * @param data 矩阵
 * @param index 行索引
 */
void reverseRow(vector>& data,
                int index) 
{
    int cols = data[index].size();
    for(int i = 0; i < cols / 2; i++) 
    {
        int temp = data[index][i];
        data[index][i] = data[index][cols - i - 1];
        data[index][cols - i - 1] = temp;
    }
}

/**
 * 打印矩阵数据
 * @param data 矩阵
 */
void printMatrix(vector>& data)
{
    for(int i = 0; i < data.size(); i++) 
    {
        for(int j = 0; j < data[i].size(); j++) 
        {
            cout << data[i][j] << " ";
        }
        cout << endl;
    }
}

/**
 * 将矩阵旋转180度
 * @param data 矩阵
 */
void rotateMatrix180(vector>& data) 
{
    int rows = data.size();
    int cols = data[0].size();

    if (rows % 2 != 0) 
    {

        // 如果N是奇数
        // 反转矩阵的中间行
        reverseRow(data, data.size() / 2);
    }

    // 每个元素与矩阵中与之对应的元素进行交换
    // 交换一半的行
   for(int i = 0; i <= (rows/2) - 1; i++)
    {
        for(int j = 0; j < cols; j++) 
        {
            int temp = data[i][j];
            data[i][j] = data[rows - i - 1][cols - j - 1];
            data[rows - i - 1][cols - j - 1] = temp;
        }
    }
}

// 主函数    
int main()
{
    vector> data{ { 1, 2, 3, 4, 5 },
                              { 6, 7, 8, 9, 10 },
                              { 11, 12, 13, 14, 15 },
                              { 16, 17, 18, 19, 20 },
                              { 21, 22, 23, 24, 25 } };

    // 将矩阵旋转
    rotateMatrix180(data);

    // 打印矩阵
    printMatrix(data);

    return 0;
}

// 该代码由divyeshrabadiya07贡献```  

输出:

25 24 23 22 21 
 20 19 18 17 16 
 15 14 13 12 11 
 10 9 8 7 6 
 5 4 3 2 1

25 24 23 22 21 
20 19 18 17 16 
15 14 13 12 11 
10 9 8 7 6 
5 4 3 2 1 

时间复杂度 : O(R*C)

辅助空间复杂度 : O(1)