Java Program to Rotate Matrix Elements
Matrix is simply a two-dimensional array. So the goal is to deal with fixed indices at which elements are present and to perform operations on indexes such that elements on the addressed should be swapped in such a manner it should lookout as the matrix is rotated. Here we will be discussing two methods in dealing with indices
- Using naive approach
- Using optimal approach
Method 1: Using naive approach
For a given matrix, the task is to rotate its elements in a clockwise direction.
Illustrations:
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
Approach:
Here, we will use loops in order to print the elements in spiral form. Where, we will rotate all the rings of the elements one by one, starting from the outermost one. And for rotating a ring, we need to do the following:
- Move the elements of the top row,
- Move the elements of the last column,
- Move the elements of the bottom row, and
- Move the elements of the first column.
Moreover, repeat the above steps if there is an inner ring as well.
Example:
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
Method 2: Using optimal approach
For a given matrix of size M×N, we need to rotate the matrix elements by k times to the right side. Where k is a number.
Approach:
An optimal approach is to observe each row of the stated matrix as an array and then execute an array rotation. It is performed by replicating the elements of the matrix from the given number k to the end of an array to the starting of the array utilizing a temporary array. And then the rest of the elements from the start to (k-1) to the end of an array.
Illustration:
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
Example:
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
Time complexity: O(R*C) where R and C are no of rows and columns of given matrix respectively
Auxiliary space: O(1) because using array tempo of size 3
Contact Us