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.
Java
// Java program to rotate a
// matrix by 180 degrees
import java.util.*;
class GFG {
static int N = 3;
// Function to Rotate the
// matrix by 180 degree
static void rotateMatrix(int mat[][])
{
// Simply print from last
// cell to first cell.
for (int i = N - 1; i >= 0; i--) {
for (int j = N - 1; j >= 0; j--)
System.out.print(mat[i][j] + " ");
System.out.println();
}
}
// Driver Code
public static void main(String[] args)
{
int[][] mat = { { 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 } };
rotateMatrix(mat);
}
}
// This code is contributed by ChitraNayal
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
Java
// Java program for left
// rotation of matrix by 180
import java.util.*;
class GFG {
static int R = 4, C = 4, t = 0;
// Function to rotate the
// matrix by 180 degree
static void reverseColumns(int arr[][])
{
for (int i = 0; i < C; i++) {
for (int j = 0, k = C - 1; j < k; j++, k--) {
t = arr[j][i];
arr[j][i] = arr[k][i];
arr[k][i] = t;
}
}
}
// Function for transpose of matrix
static void transpose(int arr[][])
{
for (int i = 0; i < R; i++) {
for (int j = i; j < C; j++) {
t = arr[i][j];
arr[i][j] = arr[j][i];
arr[j][i] = t;
}
}
}
// Function for display the matrix
static void printMatrix(int arr[][])
{
for (int i = 0; i < R; i++) {
for (int j = 0; j < C; j++)
System.out.print(arr[i][j] + " ");
System.out.println();
}
}
// Function to anticlockwise
// rotate matrix by 180 degree
static void rotate180(int arr[][])
{
transpose(arr);
reverseColumns(arr);
transpose(arr);
reverseColumns(arr);
}
// Driver Code
public static void main(String[] args)
{
int[][] arr = { { 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 },
{ 13, 14, 15, 16 } };
rotate180(arr);
printMatrix(arr);
}
}
// This code is contributed by ChitraNayal
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.
Java
public class GFG {
/**
* Reverse Row at specified index in the matrix
* @param data matrix
* @param index row index
*/
private static void reverseRow(int[][] data, int index) {
int cols = data[index].length;
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
*/
private static void printMatrix(int[][] data) {
for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data[i].length; j++) {
System.out.print(data[i][j] + " ");
}
System.out.println("");
}
}
/**
* Rotate Matrix by 180 degrees
* @param data matrix
*/
private static void rotateMatrix180(int[][] data) {
int rows = data.length;
int cols = data[0].length;
if (rows % 2 != 0) {
//If N is odd reverse the middle row in the matrix
reverseRow(data, data.length / 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;
}
}
}
public static void main(String[] args) {
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);
}
}
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.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA