# 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

Feeling lost in the vast world of Backend Development? It's time for a change! Join our Java Backend Development - Live Course and embark on an exciting journey to master backend development efficiently and on schedule.
What We Offer:
• Comprehensive Course
• Expert Guidance for Efficient Learning
• Hands-on Experience with Real-world Projects
• Proven Track Record with 100,000+ Successful Geeks

Previous
Next