 GeeksforGeeks App
Open App Browser
Continue

# Java Program to Rotate all Matrix elements except the diagonal K times by 90 degrees in clockwise direction

Given a square matrix mat[][] of dimension N and an integer K, the task is to rotate the matrix by 90 degrees K times without changing the position of the diagonal elements.

Examples:

Input: mat[][] = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15}, {16, 17, 18, 19, 20}, {21, 22, 23, 24, 25}}, K = 1
Output:
1 16 11 6 5
22 7 12 9 2
23 18 13 8 3
24 17 14 19 4
21 20 15 10 25

Input: mat[][] = {{10, 11}, {12, 13}}, K = 2
Output:
10 11
12 13

Approach: The given problem can be solved by using the idea discussed in this article and the fact that the matrix restores after performing clockwise rotation 4 times. Follow the below steps to solve the given problem:

• Update the value of K as K % 4.
• Iterate until K is a positive and perform the following steps:
• Traverse the matrix, for i over the range [0, N / 2) and j over the range[0, N – i – 1) and perform the following steps:
• If the value of i != j and (i + j) != (N – 1), then perform the following steps:
• Store the value of mat[i][j] in a temporary variable temp.
• Update the value of mat[i][j] as mat[N – 1 – j][i].
• Update the value of mat[N – 1 – j][i] as mat[N – 1 -i][N – 1 – j].
• Update the value of mat[N – 1  – i][N – 1 – j] as mat[j][N – 1 – i].
• Update the value of mat[j][N – 1 – i] as temp.
• After completing the above steps, print the updated matrix obtained.

Below is the implementation of the above approach:

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `public` `class` `GFG {` `    ``// Function to print the matrix``    ``static` `void` `print(``int` `mat[][])``    ``{``        ``// Iterate over the rows``        ``for` `(``int` `i = ``0``; i < mat.length; i++) {` `            ``// Iterate over the columns``            ``for` `(``int` `j = ``0``; j < mat[``0``].length; j++)` `                ``// Print the value``                ``System.out.print(mat[i][j] + ``" "``);``          ` `            ``System.out.println();``        ``}``    ``}` `    ``// Function to perform the swapping of``    ``// matrix elements in clockwise manner``    ``static` `void` `performSwap(``int` `mat[][], ``int` `i, ``int` `j)``    ``{``        ``int` `N = mat.length;` `        ``// Stores the last row``        ``int` `ei = N - ``1` `- i;` `        ``// Stores the last column``        ``int` `ej = N - ``1` `- j;` `        ``// Perform the swaps``        ``int` `temp = mat[i][j];``        ``mat[i][j] = mat[ej][i];``        ``mat[ej][i] = mat[ei][ej];``        ``mat[ei][ej] = mat[j][ei];``        ``mat[j][ei] = temp;``    ``}` `    ``// Function to rotate non - diagonal``    ``// elements of the matrix K times in``    ``// clockwise direction``    ``static` `void` `rotate(``int` `mat[][], ``int` `N, ``int` `K)``    ``{``        ``// Update K to K % 4``        ``K = K % ``4``;` `        ``// Iterate until K is positive``        ``while` `(K-- > ``0``) {` `            ``// Iterate each up to N/2-th row``            ``for` `(``int` `i = ``0``; i < N / ``2``; i++) {` `                ``// Iterate each column``                ``// from i to N - i - 1``                ``for` `(``int` `j = i; j < N - i - ``1``; j++) {` `                    ``// Check if the element``                    ``// at i, j is not a``                    ``// diagonal element``                    ``if` `(i != j && (i + j) != N - ``1``) {` `                        ``// Perform the swapping``                        ``performSwap(mat, i, j);``                    ``}``                ``}``            ``}``        ``}` `        ``// Print the matrix``        ``print(mat);``    ``}``  ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int` `K = ``5``;``        ``int` `mat[][] = {``            ``{ ``1``, ``2``, ``3``, ``4` `},``            ``{ ``6``, ``7``, ``8``, ``9` `},``            ``{ ``11``, ``12``, ``13``, ``14` `},``            ``{ ``16``, ``17``, ``18``, ``19` `},``        ``};``      ` `        ``int` `N = mat.length;``        ``rotate(mat, N, K);``    ``}``}` `// This code is contributed by Kingash.`

Output:

```  1 11  6  4
17  7  8  2
18 12 13  3
16 14  9 19```

Time Complexity: O(N3) since using three inner loop one while and two for loop
Auxiliary Space: O(1)

Please refer complete article on Rotate all Matrix elements except the diagonal K times by 90 degrees in clockwise direction for more details!

My Personal Notes arrow_drop_up