Java Program to Rotate Matrix Elements

21 Feb, 2022
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 
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, andMove the elements of the first column.
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 Classpublic 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 
simranarora5sos
Java
Java Programs
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.