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

1. Using naive approach 
2. 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:

1. Move the elements of the top row,
2. Move the elements of the last column,
3. Move the elements of the bottom row, and
4. 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);
    }
}

Output

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);
    }
}

Output

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