# Java Program to Rotate Matrix Elements

• Last Updated : 28 Mar, 2021

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

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

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 Staring 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 ```

My Personal Notes arrow_drop_up