Aquileo | Rotate a Matrix by 180 degree

Given a square matrix mat[][], Rotate the matrix by 180 degrees.
Note: Rotating 180° clockwise or anticlockwise gives the same result.

Examples:

Input: mat[][] = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
Output: [[9, 8, 7],
[6, 5, 4],
[3, 2, 1]]
Explanation: The output matrix is the input matrix rotated by 180 degrees.
Input: mat[][] = [[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 0, 1, 2],
[3, 4, 5, 6]]
Output: [[6, 5, 4, 3],
[2, 1, 0, 9],
[8, 7, 6, 5],
[4, 3, 2, 1]]
Explanation: The output matrix is the input matrix rotated by 180 degrees.

Try It Yourself

Table of Content

[Approach 1] Rotate 90 Degree Twice - O(n^2) Time and O(1) Space
[Approach 2] Using Auxiliary Matrix - O(n^2) Time and O(n^2) Space
[Approach 3] In-Place Swapping - O(n^2) Time and O(1) Space

[Approach 1] Rotate 90 Degree Twice - O(n^2) Time and O(1) Space

A simple solution is to use the solutions discussed in Rotate 90 Degree Counterclockwise or Rotate 90 Degree Clockwise two times. These solutions require more effort. We can solve this problem more efficiently by directly finding a relationship between the original matrix and 180 degree rotated matrix.

[Approach 2] Using Auxiliary Matrix - O(n^2) Time and O(n^2) Space

If we take a closer look at the examples, we can notice that after rotation, the first element in the top row moves to the last cell in the last row. Similarly, second element in the top row moves to the second last cell in the last row, and so on. In general, we can notice that mat[i][j] needs to be placed at cell [n-i-1][n-j-1]. So, we can create a new matrix and place all the elements at their correct position. Finally, we copy all the elements from new matrix to the original matrix.

C++

#include <iostream>
#include <vector>
using namespace std;

void rotateMatrix(vector<vector<int>>& mat) {
    int n = mat.size();
  
    // Create an auxiliary matrix
    vector<vector<int>> res(n, vector<int>(n));
  
    // move mat[i][j] to mat[n-i-1][n-j-1]
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            res[i][j] = mat[n - i - 1][n - j - 1];
        }
    }
    mat = res;
}

int main() {
    vector<vector<int>> mat = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    rotateMatrix(mat);
    for (int i = 0; i < mat.size(); i++) {
        for (int j = 0; j < mat[i].size(); j++) {
            cout << mat[i][j] << " ";
        }
        cout << "\n";
    }

    return 0;
}

#include <stdio.h>

void rotateMatrix(int n, int mat[n][n]) {
   
    // Create an auxiliary matrix
    int res[n][n];

    // move mat[i][j] to mat[n-i-1][n-j-1]
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            res[i][j] = mat[n - i - 1][n - j - 1];
        }
    }

    // Copy back to original matrix
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            mat[i][j] = res[i][j];
        }
    }
}

int main() {
    int n = 3;
    int mat[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    rotateMatrix(n, mat);

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", mat[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Java

class GfG {

    static void rotateMatrix(int[][] mat) {
        int n = mat.length;
        
        // Create an auxiliary matrix
        int[][] res = new int[n][n];

        // Move mat[i][j] to mat[n-i-1][n-j-1]
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                res[i][j] = mat[n - i - 1][n - j - 1];
            }
        }

        // Copy result back to the original matrix
        for (int i = 0; i < n; i++) {
            System.arraycopy(res[i], 0, mat[i], 0, n);
        }
    }

    public static void main(String[] args) {
        int[][] mat = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        rotateMatrix(mat);

        for (int[] row : mat) {
            for (int x : row) {
                System.out.print(x + " ");
            }
            System.out.println();
        }
    }
}

Python

def rotateMatrix(mat):
    n = len(mat)
  
    # Create an auxiliary matrix
    res = [[0] * n for _ in range(n)]
  
    # Move mat[i][j] to mat[n-i-1][n-j-1]
    for i in range(n):
        for j in range(n):
            res[i][j] = mat[n - i - 1][n - j - 1]
    
    # Copy result back to original matrix
    for i in range(n):
        for j in range(n):
            mat[i][j] = res[i][j]

if __name__ == "__main__":
    mat = [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ]

    rotateMatrix(mat)

    for row in mat:
        print(" ".join(map(str, row)))

using System;

class GfG {

    static void rotateMatrix(int[,] mat) {
        int n = mat.GetLength(0);
        
        // Create an auxiliary matrix
        int[,] res = new int[n, n];

        // Move mat[i][j] to mat[n-i-1][n-j-1]
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                res[i, j] = mat[n - i - 1, n - j - 1];
            }
        }

        // Copy result back to original matrix
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                mat[i, j] = res[i, j];
            }
        }
    }

    public static void Main() {
        int[,] mat = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        rotateMatrix(mat);

        int n = mat.GetLength(0);
        int m = mat.GetLength(1);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                Console.Write(mat[i, j] + " ");
            }
            Console.WriteLine();
        }
    }
}

JavaScript

function rotateMatrix(mat) {
    const n = mat.length;

    // Create an auxiliary matrix
    const res = Array.from({ length: n }, () => 
                                    Array(n).fill(0));

    // Move mat[i][j] to mat[n-i-1][n-j-1]
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n; j++) {
            res[i][j] = mat[n - i - 1][n - j - 1];
        }
    }

    // Copy result back to original matrix
    for (let i = 0; i < n; i++) {
        mat[i] = res[i].slice();
    }
}

// Driver code
const mat = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];
rotateMatrix(mat);
mat.forEach(row => console.log(row.join(" ")));

Output

9 8 7 
6 5 4 
3 2 1

[Approach 3] In-Place Swapping - O(n^2) Time and O(1) Space

In the above approach, we are placing mat[i][j] at cell [n-i-1][n-j-1]. However, instead of placing mat[i][j] at cell [n-i-1][n-j-1] in a new matrix, we can observe that mat[n-i-1][n-j-1] is also being placed back at mat[i][j]. So, rather than performing this in two separate matrices, we can handle it in same matrix by simply swapping mat[i][j] and mat[n-i-1][n-j-1].

If the matrix has an odd number of rows, the middle row won’t have an opposite to swap with, so we need to handle it separately. This middle row elements have to be reversed among themselves.

rotate_a_matrix_by_180_degee — Rotate a matrix 180 degree by in-place swapping

C++

#include <iostream>
#include <vector>
using namespace std;

void rotateMatrix(vector<vector<int>>& mat) {
    int n = mat.size();
  
    // Swap elements from the start and end to
    // rotate by 180 degrees
    for (int i = 0; i < n / 2; i++) {
        for (int j = 0; j < n; j++) {
            swap(mat[i][j], mat[n - i - 1][n - j - 1]);
        }
    }
  
    // Handle the middle row if the matrix 
    // has odd dimensions
    if (n % 2 != 0) {
        int mid = n / 2;
        for (int j = 0; j < n/2; j++)
            swap(mat[mid][j], mat[mid][n - j - 1]);
    }
}

int main() {
    vector<vector<int>> mat = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    rotateMatrix(mat);
    for (int i = 0; i < mat.size(); i++) {
        for (int j = 0; j < mat[i].size(); j++) {
            cout << mat[i][j] << " ";
        }
        cout << "\n";
    }

    return 0;
}

#include <stdio.h>

void rotateMatrix(int n, int mat[n][n]) {

    // Swap elements from the start and end to
    // rotate by 180 degrees
    for (int i = 0; i < n / 2; i++) {
        for (int j = 0; j < n; j++) {
            int temp = mat[i][j];
            mat[i][j] = mat[n - i - 1][n - j - 1];
            mat[n - i - 1][n - j - 1] = temp;
        }
    }

    // Handle the middle row if the matrix 
    // has odd dimensions
    if (n % 2 != 0) {
        int mid = n / 2;
        for (int j = 0; j < n / 2; j++) {
            int temp = mat[mid][j];
            mat[mid][j] = mat[mid][n - j - 1];
            mat[mid][n - j - 1] = temp;
        }
    }
}

int main() {
    int n = 3;
    int mat[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    rotateMatrix(n, mat);

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", mat[i][j]);
        }
        printf("\n");
    }

    return 0;
}