Dada una matriz representada como int [n] [n], gírela 90 grados en sentido horario en el lugar. (En el lugar significa un mínimo de memoria adicional para usar, es decir, no haga una nueva matriz para copiar).

Para rotar una matriz a 90 grados en el lugar, debe ser una matriz cuadrada que tenga el mismo número de filas y columnas; de lo contrario, la solución en el lugar no es posible y requiere cambios en la fila / columna.

Es muy fácil resolver este problema si se comprende bien.

Para rotar una matriz a 90 grados, comenzaremos a rotarla capa por capa.
Gire la primera capa externa 90 grados, Rote la 2da capa interna 90 grados, Gire la 3ra capa interna 90 grados y así sucesivamente,

Vamos a romper aún más el problema de rotar cada capa para rotar cada celda de la capa en 90 grados.
Comenzando desde la celda más a la izquierda de la capa 1, primero la rotaremos a 90 grados y nos moveremos a su posición correcta.
Elija la segunda celda de la capa 1 y gírela a 90 grados y muévala a su posición correcta y así sucesivamente.

Después de la primera iteración, la capa 1 se rotará completamente a 90 grados.
Ahora elija la capa 2 y repita el mismo proceso.

En cada iteración, estamos trabajando en una capa externa completa que consta de 2 filas
(Ejemplo: fila 0 y fila 4 para la capa 1)
Entonces, mientras codificamos debemos ocuparnos de esto y debemos iterar nuestro bucle externo de 0 a rowLength / 2 y no hasta rowLength.

for (int i = 0; i <= (length)/2; i++)

Para el bucle interno, debe comenzar desde donde comienza el bucle externo y disminuye la capa final en cada iteración porque en cada iteración, la pared izquierda y la pared derecha de la matriz se giran, por lo que no es necesario tocarla en la próxima iteración.

for (int j = i; j < length-i; j++) {

Primero recopilaremos datos de las 4 celdas que forman 90 grados y deben rotarse, luego lo cambiaremos a una ubicación de 90 grados.

Ejemplo: Mientras gira la primera celda de la Capa 1, debemos hacer las siguientes operaciones.
Los datos en la celda en (0,0) deben moverse a la celda (0,4).
Los datos en la celda en (0,4) deben moverse a la celda (4,4).
Los datos en la celda en (4,4) deben moverse a la celda (4,0).
Los datos en la celda en (4,0) deben moverse a la celda (0,0).

Elija la segunda celda de la Capa 1 e identifique la ubicación correspondiente de 90 grados de las 4 celdas e intercambie la ubicación.
Continuar la operación para todas las celdas de la capa 1.

Después de rotar la capa 1, debemos trabajar en la capa 2, pero antes de comenzar a trabajar en la capa 2,
necesitamos aumentar nuestra capa externa para comenzar desde la siguiente fila y la capa interna también para comenzar desde la siguiente fila y terminar en la filaLongitud-1 ya que la pared derecha de la matriz ya está rotada en la rotación de la capa 1.

Elija la capa 2 y repita el proceso.

  public void rotateMatrixInplace (int [] [] matrix) {
		 int longitud = matrix.length-1;

		 for (int i = 0; i <= (length) / 2; i ++) {
			 para (int j = i; j <longitud-i; j ++) {

				 int temp = matriz [i] [j];

				 matriz [i] [j] = matriz [longitud-j] [i];
				 matriz [longitud-j] [i] = matriz [longitud-i] [longitud-j];
				 matriz [longitud-i] [longitud-j] = matriz [j] [longitud-i];
				 matriz [j] [longitud-i] = temp;
			 }
		 }
	 }

Explicación detallada con el programa:

Gire la matriz N * N 90 grados en sentido horario Inplace
Gire la matriz N * M 90 grados

La descripción “Girar en sentido horario: significa que la fila superior se convierte en la columna derecha, la columna derecha se convierte en la fila inferior, etc.” en la pregunta es un poco ambigua.
Supongo que la transformación necesaria es como se ilustra en este ejemplo.
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
se convierte
13 9 5 1
14 10 6 2
15 11 7 3
16 12 8 4

Editar: Aquí hay una respuesta más simple para rotar la matriz en su lugar, cuya idea es la misma que la publicada por anónimo.

 for (int i = 0; i <= (n-1)/2; i++) { for (int j = i; j < ni-1; j++) { int p1 = A[i][j]; int p2 = A[j][ni-1]; int p3 = A[ni-1][nj-1]; int p4 = A[nj-1][i]; A[j][ni-1] = p1; A[ni-1][nj-1] = p2; A[nj-1][i] = p3; A[i][j] = p4; } } 

Respuesta previa

Calcule la transposición de una matriz dada utilizando el procedimiento recursivo de estilo C simple con una llamada inicial para transponer (A, 0).

transponer (A, s) {
if (s == n-1) devuelve;
para (i = s; i // hacer que la fila superior más izquierda quede más col y la izquierda más col superior fila superior
transponer (A, s + 1); // transponer recursivamente la matriz restante (n-1) x (n-1)
}

La matriz que ahora tenemos es
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16

intercambia cada par de columnas simétricas verticalmente. (col 1, col n), (col 2, col n-1),…

entonces obtenemos la matriz

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

Solución simple en dos pasos:

1.Encontrar la transposición de una matriz.

2. Invierta los elementos de cada columna de matriz transpuesta.

Aquí está el código:

anular Rotate90 (int mat [R] [C])

{

transponer (mat);

reversecol (mat);

}

transposición nula (int mat [R] [C])

{

para (int i = 0; i

{

para (int j = i; j

{

swap (mat [i] [j], mat [j] [i]);

}

}

Anular reversecol (int mat [R] [C])

{

para (int i = 0; i

{

para (int k = C-1, j = 0; k> j, k—, j ++)

{

swap (mat [j] [i], mat [k] [i]);

}

Sin complejidad espacial, complejidad temporal – O (RXC)

Aquí está mi implementación recursiva. Utiliza la estrategia de dividir y conquistar para dividir la matriz en 4 submatrices, rotarlas individualmente y luego rotar la matriz original girando estas matrices en sentido horario
(la sumbatriz inferior derecha se convierte en la parte inferior izquierda, la inferior izquierda se convierte en la parte superior izquierda, la superior izquierda se convierte en la parte superior derecha y la superior derecha se convierte en la parte inferior derecha)

#include
#include
usando el espacio de nombres estándar;
int Matriz [8] [8];

void RecursiveRotate (int x, int y, int r, int c);
int main ()
{
cout << "Tamaño:";
tamaño int;
cin >> tamaño;

para (int i = 0; i para (int j = 0; j scanf (“% d”, y Matriz [i] [j]);

printf (“\ nMatriz original: \ n”);
para (int i = 0; i {
para (int j = 0; j {
cout << Matriz [i] [j] << "";
}
cout << "\ n";
}

RecursiveRotate (0,0, tamaño, tamaño);

cout << "\ n \ nDespués de la rotación: \ n";

para (int i = 0; i {
para (int j = 0; j {
cout << Matriz [i] [j] << "";
}
cout << "\ n";
}

}

void ClockwiseRotate (int x, int y, int row, int col)
{
int tmp;
para (int i = x; i {
para (int j = y; j {
tmp = Matriz [i] [j];
Matriz [i] [j] = Matriz [i + fila / 2] [j];
Matriz [i + fila / 2] [j] = Matriz [i + fila / 2] [j + col / 2];
Matriz [i + fila / 2] [j + col / 2] = Matriz [i] [j + col / 2];
Matriz [i] [j + col / 2] = tmp;
}
}
}

void RecursiveRotate (int x, int y, int row, int col)
{
if (fila == 1 && col == 1)
regreso; //caso base
RecursiveRotate (x, y + col / 2, row / 2, col / 2); // submatriz superior derecha
RecursiveRotate (x + fila / 2, y + col / 2, fila / 2, col / 2); // abajo a la derecha
RecursiveRotate (x + row / 2, y, row / 2, col / 2); // abajo a la izquierda
RecursiveRotate (x, y, row / 2, col / 2); // arriba a la izquierda
Girar en sentido horario (x, y, fila, col); // enviando coordenadas de} // elemento de la submatriz superior izquierda

Una manera muy simple es hacer dos rotaciones. Uno a lo largo de (0,0) – (n, n) diagonal y el segundo verticalmente desde el centro.

Entonces primero:

Intercambio (A [i, j], A [j, i])

Segundo:

Intercambio (A [i, j], A [i, nj])

Esto haría dos rotaciones en n ^ 2 rango.

Se necesita memoria adicional para 1 variable.

(Suponga índices basados ​​en cero).

Para a[i][j] (entrada en la i-ésima fila y la j-ésima columna), se “moverá” a a[j][n-1-i] . Si construimos el siguiente gráfico:

  • n ^ 2 nodos: a[i][j]
  • n ^ 2 aristas dirigidas: transición a[i][j] → a[j][n-1-i]

se puede verificar fácilmente que (bueno, solo visualmente, la prueba algebraica explícita sería una exageración) cada nodo está involucrado en un ciclo de longitud 4 o 1. Por lo tanto, el problema original se reduce a listas rotativas de elementos de tamaño <= 4 .

El problema reducido se puede hacer con solo 1 unidad adicional de memoria.

Aquí hay un forro de python 2:

  def rotate90 (A):
     # Reflejo horizontal
	 A.reverse ()
	 # Transponer A
	 A = mapa (lista, código postal (* A))
	 devolver A

 A = [[1,2,3,4], [5,6,7,8], [9,10,11,12], [13,14,15,16]]
 rotar90 (A)
  int l, k, a [10] [10], b [10] [10]; 
 l = 3;

 para (i = 0; i 

Este es probablemente el código más simple para un cambio de 90 ° de matriz 3 × 3 en sentido horario

Gire una matriz de 90 grados, 180 grados, 270 grados, 360 grados.

  #include 
 usando el espacio de nombres estándar;

 int main ()
 {
	 int n, d;
	 cin >> n;
	 cout << "Grados";
	 cin >> d;
	 d = d / 90;
	 int arr [n] [n];
	 int arr1 [n] [n] = {0};
	
	
	 para (int i = 0; i > arr [i] [j];

	 para (int k = 0; k 

Este código está usando una nueva matriz. Esta no es una memoria mínima que usa código.

More Interesting

¿Cuáles son las preguntas de la entrevista más frecuentes (técnicas y de recursos humanos, ambas) para estudiantes de ingeniería informática?

¿Cuál es la mejor manera de prepararse para la entrevista de Google en 3 meses?

¿Qué tipo de preguntas hace Interviewstreet en la ronda telefónica?

Cómo medir la calidad del código

¿Puedo pedir más tiempo para resolver una pregunta de algoritmo en la entrevista técnica?

¿Qué preguntas se hacen en una entrevista para el pasante de ingeniería de software?

¿Qué libros de programación son los mejores para descifrar entrevistas de codificación?

Durante una entrevista, ¿cómo respondería a la pregunta "describa lo que sabe sobre el aprendizaje automático"?

¿Lógica detrás del programa para verificar si el número es palíndromo o no?

¿Debo conocer las estructuras de datos y los algoritmos para una entrevista para un puesto en aprendizaje automático / profundo? Vengo de EE y no he estudiado DS&A

¿Cuál será un buen libro o revista para seguir para programar entrevistas requeridas en prácticas y entrevistas posteriores a la graduación de colegios / universidades?

He estado luchando durante un año para aprender algoritmos y todavía no puedo pasar ninguna entrevista técnica, ¿qué debo hacer?

¿Qué cubren las entrevistas de programación aparte de las estructuras de datos y algoritmos?

¿Por qué EPFL no produce grandes programadores que puedan descifrar entrevistas técnicas de compañías como Google, Facebook, Palantir, Amazon, etc.?

¿Cuánto tiempo le tomaría a un desarrollador de software profesional sin conocimientos de algoritmos / estructura de datos prepararse para entrevistas de ingeniería de primer nivel?