Programa en C++ para rotar una array 180 grados

Dada una array cuadrada, la tarea es que la giremos 180 grados en sentido contrario a las agujas del reloj sin usar ningún espacio extra. 

Ejemplos: 

Input :  1  2  3
         4  5  6
         7  8  9
Output : 9 8 7 
         6 5 4 
         3 2 1

Input :  1 2 3 4 
         5 6 7 8 
         9 0 1 2 
         3 4 5 6 
Output : 6 5 4 3 
         2 1 0 9 
         8 7 6 5 
         4 3 2 1

Método: 1 (Solo imprime array rotada) 
La solución a este problema es que para rotar una array 180 grados podemos seguir fácilmente ese paso 

Matrix =  a00 a01 a02
          a10 a11 a12
          a20 a21 a22

when we rotate it by 90 degree
then matrix is
Matrix = a02 a12 a22
         a01 a11 a21
         a00 a10 a20
  
when we rotate it by again 90 
degree then matrix is 
Matrix = a22 a21 a20
         a12 a11 a10
         a02 a01 a00 

De la ilustración anterior , obtenemos que simplemente para rotar la array 180 grados, tendremos que imprimir la array dada de manera inversa.

// C++ program to rotate a matrix by 180 degrees
#include <bits/stdc++.h>
#define N 3
using namespace std;
  
// Function to Rotate the matrix by 180 degree
void rotateMatrix(int mat[][N])
{
    // Simply print from last cell to first cell.
    for (int i = N - 1; i >= 0; i--) {
        for (int j = N - 1; j >= 0; j--)
            printf("%d ", mat[i][j]);
  
        printf("
");
    }
}
  
// Driven code
int main()
{
    int mat[N][N] = {
        { 1, 2, 3 },
        { 4, 5, 6 },
        { 7, 8, 9 }
    };
  
    rotateMatrix(mat);
    return 0;
}

Producción : 

 9 8 7 
 6 5 4 
 3 2 1  

Complejidad temporal: O(N*N) 
Espacio auxiliar: O(1)

Método: 2 (Rotación en el lugar) 
Hay cuatro pasos: 
1- Encuentra la transpuesta de una array. 
2- Columnas inversas de la transpuesta. 
3- Hallar la transpuesta de una array. 
4- Columnas inversas de la transpuesta

Let the given matrix be
1  2  3  4
5  6  7  8
9  10 11 12
13 14 15 16

First we find transpose.
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16

Then we reverse elements of every column.
4 8 12 16
3 7 11 15
2 6 10 14
1 5  9 13

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

Then we reverse elements of every column again
16 15 14 13 
12 11 10 9 
8 7 6 5 
4 3 2 1

// C++ program for left rotation of matrix by 180
#include <bits/stdc++.h>
using namespace std;
  
#define R 4
#define C 4
  
// Function to rotate the matrix by 180 degree
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]);
}
  
// Function for transpose of matrix
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]);
}
  
// Function for display the matrix
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 << '
';
    }
}
  
// Function to anticlockwise rotate matrix
// by 180 degree
void rotate180(int arr[R][C])
{
    transpose(arr);
    reverseColumns(arr);
    transpose(arr);
    reverseColumns(arr);
}
  
// Driven code
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;
}

Producción : 

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

Complejidad temporal: O(R*C) 
Espacio auxiliar: O(1)
En el código anterior, la transposición de la array debe encontrarse dos veces y, además, las columnas deben invertirse dos veces. 
Entonces, podemos tener una mejor solución.

Método: 3 (Intercambio de posición)
Aquí, intercambiamos los valores en las posiciones respectivas. 

#include <bits/stdc++.h>
using namespace std;
  
/**
 * Reverse Row at specified index in the matrix
 * @param data matrix
 * @param index row index
 */
void reverseRow(vector<vector<int>>& 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;
    }
}
  
/**
 * Print Matrix data
 * @param data matrix
 */
void printMatrix(vector<vector<int>>& data)
{
    for(int i = 0; i < data.size(); i++) 
    {
        for(int j = 0; j < data[i].size(); j++) 
        {
            cout << data[i][j] << " ";
        }
        cout << endl;
    }
}
  
/**
 * Rotate Matrix by 180 degrees
 * @param data matrix
 */
void rotateMatrix180(vector<vector<int>>& data) 
{
    int rows = data.size();
    int cols = data[0].size();
  
    if (rows % 2 != 0) 
    {
          
        // If N is odd reverse the middle 
        // row in the matrix
        reverseRow(data, data.size() / 2);
    }
      
    // Swap the value of matrix [i][j] with
    // [rows - i - 1][cols - j - 1] for half     
    // the rows size. 
    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;
        }
    }
}
  
// Driver code    
int main()
{
    vector<vector<int>> 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 } };
  
    // Rotate Matrix
    rotateMatrix180(data);
  
    // Print Matrix
    printMatrix(data);
  
    return 0;
}
  
// This code is contributed by divyeshrabadiya07

Producción : 

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 

Complejidad temporal : O(R*C) 
Espacio auxiliar : O(1)
 

Consulte el artículo completo sobre Rotar una array 180 grados para obtener más detalles.