Matrix es simplemente una array bidimensional. Entonces, el objetivo es tratar con índices fijos en los que los elementos están presentes y realizar operaciones en los índices de modo que los elementos en el direccionado se intercambien de tal manera que se observe a medida que se gira la array. Aquí discutiremos dos métodos para tratar con índices.
- Usando un enfoque ingenuo
- Usando el enfoque óptimo
Método 1: Usar un enfoque ingenuo
Para una array dada, la tarea es rotar sus elementos en el sentido de las agujas del reloj.
Ilustraciones:
For 4*4 matrix Input: 7 8 9 10 11 12 2 3 4 Output: 10 7 8 2 11 9 3 4 12
For 4*4 matrix Input: 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 Output: 8 4 5 6 12 13 9 7 16 14 10 11 17 18 19 15
Acercarse:
Aquí, usaremos bucles para imprimir los elementos en forma de espiral. Donde, rotaremos todos los anillos de los elementos uno por uno, comenzando por el más externo. Y para rotar un anillo, necesitamos hacer lo siguiente:
- Mover los elementos de la fila superior,
- Mover los elementos de la última columna,
- Mueva los elementos de la fila inferior y
- Mueve los elementos de la primera columna.
Además, repita los pasos anteriores si también hay un anillo interior.
Ejemplo:
Java
// Java Program to Rotate Matrix Elements
// Importing classes from java.lang package
import java.lang.*;
// Importing classes from java.util package
import java.util.*;
// main Class
class GFG {
static int r = 4;
static int c = 4;
// Method
// To rotate a matrix of
// dimension r x c. And initially,
// p = r and q = c
static void rotate_matrix(int p, int q, int matrix[][])
{
int rw = 0, cl = 0;
int previous, current;
// rw is the Starting row index
// p is the ending row index
// cl is the starting column index
// q is the ending column index and
// x is the iterator
while (rw < p && cl < q) {
if (rw + 1 == p || cl + 1 == q)
break;
// After storing the first element of the
// next row, this element will substitute
// the first element of the current row
previous = matrix[rw + 1][cl];
// Moving the elements of the first row
// from rest of the rows
for (int x = cl; x < q; x++) {
current = matrix[rw][x];
matrix[rw][x] = previous;
previous = current;
}
rw++;
// Moving the elements of the last column
// from rest of the columns
for (int x = rw; x < p; x++) {
current = matrix[x][q - 1];
matrix[x][q - 1] = previous;
previous = current;
}
q--;
// Moving the elements of the last row
// from rest of the rows
if (rw < p) {
for (int x = q - 1; x >= cl; x--) {
current = matrix[p - 1][x];
matrix[p - 1][x] = previous;
previous = current;
}
}
p--;
// Moving elements of the first column
// from rest of the rows
if (cl < q) {
for (int x = p - 1; x >= rw; x--) {
current = matrix[x][cl];
matrix[x][cl] = previous;
previous = current;
}
}
cl++;
}
// Prints the rotated matrix
for (int x = 0; x < r; x++) {
for (int y = 0; y < c; y++)
System.out.print(matrix[x][y] + " ");
System.out.print("\n");
}
}
// Method 2
// Main driver method
public static void main(String[] args)
{
// Custom input array
int b[][] = { { 5, 6, 7, 8 },
{ 1, 2, 3, 4 },
{ 0, 15, 6, 5 },
{ 3, 1, 2, 12 } };
// Calling function(Method1) to rotate matrix
rotate_matrix(r, c, b);
}
}
1 5 6 7 0 15 2 8 3 6 3 4 1 2 12 5
Método 2: Usar el enfoque óptimo
Para una array dada de tamaño M×N, necesitamos rotar los elementos de la array k veces hacia el lado derecho. Donde k es un número.
Acercarse:
Un enfoque óptimo es observar cada fila de la array indicada como una array y luego ejecutar una rotación de array. Se realiza replicando los elementos de la array desde el número k dado hasta el final de una array hasta el comienzo de la array utilizando una array temporal. Y luego el resto de los elementos desde el inicio hasta ( k -1) hasta el final de una array.
Ilustración:
Input : M = 3, N = 3, k = 2
1 2 3
4 5 6
7 8 9
Output : 2 3 1
5 6 4
8 9 7
Input : M = 2, N = 2, k = 2
11 12
13 14
Output : 11 12
13 14
Ejemplo:
Java
// Java Program to Rotate Matrix to Right Side by K Times
// Main Class
public class GFG {
// Dimension of the matrix
// Initializing to custom values
static final int P = 3;
static final int Q = 3;
// Method 1
// To rotate the stated matrix by K times
static void rotate_Matrix(int mat[][], int K)
{
// Using temporary array of dimension P
int tempo[] = new int[P];
// Rotating matrix by k times across the size of
// matrix
K = K % P;
for (int j = 0; j < Q; j++) {
// Copying first P-K elements
// to the temporary array
for (int l = 0; l < P - K; l++)
tempo[l] = mat[j][l];
// Copying the elements of the matrix
// from K to the end to the starting
for (int x = P - K; x < P; x++)
mat[j][x - P + K] = mat[j][x];
// Copying the elements of the matrix
// from the temporary array to end
for (int x = K; x < P; x++)
mat[j][x] = tempo[x - K];
}
}
// Method 2
// To show the resultant matrix
static void show_Matrix(int mat[][])
{
for (int j = 0; j < Q; j++) {
for (int x = 0; x < P; x++)
System.out.print(mat[j][x] + " ");
System.out.println();
}
}
// Method 3
// Main driver method
public static void main(String[] args)
{
// Custom input array
int mat[][]
= { { 1, 2, 5 }, { 3, 4, 6 }, { 8, 10, 9 } };
// Custom value of K
int K = 2;
// Calling the above created method for
// rotating matrix by k times
rotate_Matrix(mat, K);
// Calling the above method for
// displaying rotated matrix
show_Matrix(mat);
}
}
2 5 1 4 6 3 10 9 8
Complejidad de tiempo : O (R * C) donde R y C no son filas y columnas de la array dada, respectivamente
Publicación traducida automáticamente
Artículo escrito por Kanchan_Ray y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA