将矩阵旋转180度

给定一个正方形矩阵，任务是我们在不使用任何额外空间的情况下将其沿逆时针方向旋转180度。

例子 ：

Input :  1  2  3
         4  5  6
         7  8  9
Output : 9 8 7 
         6 5 4 
         3 2 1

Input :  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

方法：1(仅打印旋转矩阵)
这个问题的解决方案是将矩阵旋转180度，我们可以轻松地执行该步骤

Matrix =  a00 a01 a02
          a10 a11 a12
          a20 a21 a22

when we rotate it by 90 degree
then matrix is
Matrix = a02 a12 a22
         a01 a11 a21
         a00 a10 a20
  
when we rotate it by again 90 
degree then matrix is 
Matrix = a22 a21 a20
         a12 a11 a10
         a02 a01 a00 

从上面的插图中我们可以简单地将矩阵旋转180度，然后必须以相反的方式打印给定的矩阵。

C++

// C++ program to rotate a matrix by 180 degrees
#include 
#define N 3
using namespace std;
 
// Function to Rotate the matrix by 180 degree
void rotateMatrix(int mat[][N])
{
    // Simply print from last cell to first cell.
    for (int i = N - 1; i >= 0; i--) {
        for (int j = N - 1; j >= 0; j--)
            printf("%d ", mat[i][j]);
 
        printf("\n");
    }
}
 
// Driven code
int main()
{
    int mat[N][N] = {
        { 1, 2, 3 },
        { 4, 5, 6 },
        { 7, 8, 9 }
    };
 
    rotateMatrix(mat);
    return 0;
}

Java

// Java program to rotate a
// matrix by 180 degrees
import java.util.*;
 
class GFG {
    static int N = 3;
 
    // Function to Rotate the
    // matrix by 180 degree
    static void rotateMatrix(int mat[][])
    {
 
        // Simply print from last
        // cell to first cell.
        for (int i = N - 1; i >= 0; i--) {
            for (int j = N - 1; j >= 0; j--)
                System.out.print(mat[i][j] + " ");
 
            System.out.println();
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int[][] mat = { { 1, 2, 3 },
                        { 4, 5, 6 },
                        { 7, 8, 9 } };
 
        rotateMatrix(mat);
    }
}
 
// This code is contributed by ChitraNayal

Python3

# Python3 program to
# rotate a matrix by
# 180 degrees
N = 3;
 
# Function to Rotate
# the matrix by 180 degree
def rotateMatrix(mat):
     
    # Simply print from
    # last cell to first cell.
    i = N - 1;
    while(i >= 0):
        j = N - 1;
        while(j >= 0):
            print(mat[i][j], end = " ");
            j = j - 1;
        print();
        i = i - 1;
 
# Driven code
mat = [[1, 2, 3],
       [ 4, 5, 6 ],
       [ 7, 8, 9 ]];
rotateMatrix(mat);
 
# This code is contributed
# by mits

C#

// C# program to rotate a
// matrix by 180 degrees
using System;
 
class GFG {
    static int N = 3;
 
    // Function to Rotate the
    // matrix by 180 degree
    static void rotateMatrix(int[, ] mat)
    {
        // Simply print from last
        // cell to first cell.
        for (int i = N - 1; i >= 0; i--) {
            for (int j = N - 1; j >= 0; j--)
                Console.Write(mat[i, j] + " ");
 
            Console.WriteLine();
        }
    }
 
    // Driver Code
    static public void Main()
    {
        int[, ] mat = { { 1, 2, 3 },
                        { 4, 5, 6 },
                        { 7, 8, 9 } };
 
        rotateMatrix(mat);
    }
}
 
// This code is contributed by aj_36

PHP

= 0; $i--)
    {
        for ($j = $N - 1; $j >= 0; $j--)
            echo $mat[$i][$j], " ";
         
    echo "\n";
    }
}
 
// Driver Code
$mat = array(array(1, 2, 3),
             array(4, 5, 6),
             array(7, 8, 9));
 
rotateMatrix($mat);
 
// This code is contributed by ajit
?>

输出 ：

9 8 7 
 6 5 4 
 3 2 1  

时间复杂度： O(N * N)
辅助空间： O(1)

方法：2(就地旋转)
分为四个步骤：
1-找到矩阵的转置。
2-转置的反向列。
3-找到矩阵的转置。
4-转置的反向列

Let the given matrix be
1  2  3  4
5  6  7  8
9  10 11 12
13 14 15 16

First we find transpose.
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16

Then we reverse elements of every column.
4 8 12 16
3 7 11 15
2 6 10 14
1 5  9 13

then transpose again 
4 3 2 1 
8 7 6 5 
12 11 10 9
16 15 14 13 

Then we reverse elements of every column again
16 15 14 13 
12 11 10 9 
8 7 6 5 
4 3 2 1

C++

// C++ program for left rotation of matrix by 180
#include 
using namespace std;
 
#define R 4
#define C 4
 
// Function to rotate the matrix by 180 degree
void reverseColumns(int arr[R][C])
{
    for (int i = 0; i < C; i++)
        for (int j = 0, k = C - 1; j < k; j++, k--)
            swap(arr[j][i], arr[k][i]);
}
 
// Function for transpose of matrix
void transpose(int arr[R][C])
{
    for (int i = 0; i < R; i++)
        for (int j = i; j < C; j++)
            swap(arr[i][j], arr[j][i]);
}
 
// Function for display the matrix
void printMatrix(int arr[R][C])
{
    for (int i = 0; i < R; i++) {
        for (int j = 0; j < C; j++)
            cout << arr[i][j] << " ";
        cout << '\n';
    }
}
 
// Function to anticlockwise rotate matrix
// by 180 degree
void rotate180(int arr[R][C])
{
    transpose(arr);
    reverseColumns(arr);
    transpose(arr);
    reverseColumns(arr);
}
 
// Driven code
int main()
{
    int arr[R][C] = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
    rotate180(arr);
    printMatrix(arr);
    return 0;
}

Java

// Java program for left
// rotation of matrix by 180
import java.util.*;
 
class GFG {
    static int R = 4, C = 4, t = 0;
 
    // Function to rotate the
    // matrix by 180 degree
    static void reverseColumns(int arr[][])
    {
        for (int i = 0; i < C; i++) {
            for (int j = 0, k = C - 1; j < k; j++, k--) {
                t = arr[j][i];
                arr[j][i] = arr[k][i];
                arr[k][i] = t;
            }
        }
    }
 
    // Function for transpose of matrix
    static void transpose(int arr[][])
    {
        for (int i = 0; i < R; i++) {
            for (int j = i; j < C; j++) {
                t = arr[i][j];
                arr[i][j] = arr[j][i];
                arr[j][i] = t;
            }
        }
    }
 
    // Function for display the matrix
    static void printMatrix(int arr[][])
    {
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++)
                System.out.print(arr[i][j] + " ");
            System.out.println();
        }
    }
 
    // Function to anticlockwise
    // rotate matrix by 180 degree
    static void rotate180(int arr[][])
    {
        transpose(arr);
        reverseColumns(arr);
        transpose(arr);
        reverseColumns(arr);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int[][] arr = { { 1, 2, 3, 4 },
                        { 5, 6, 7, 8 },
                        { 9, 10, 11, 12 },
                        { 13, 14, 15, 16 } };
 
        rotate180(arr);
        printMatrix(arr);
    }
}
 
// This code is contributed by ChitraNayal

C＃

// C# program for left
// rotation of matrix by 180
using System;
 
class GFG {
    static int R = 4, C = 4, t = 0;
 
    // Function to rotate the
    // matrix by 180 degree
    static void reverseColumns(int[, ] arr)
    {
        for (int i = 0; i < C; i++) {
            for (int j = 0, k = C - 1;
                 j < k; j++, k--) {
                t = arr[j, i];
                arr[j, i] = arr[k, i];
                arr[k, i] = t;
            }
        }
    }
 
    // Function for transpose of matrix
    static void transpose(int[, ] arr)
    {
        for (int i = 0; i < R; i++) {
            for (int j = i; j < C; j++) {
                t = arr[i, j];
                arr[i, j] = arr[j, i];
                arr[j, i] = t;
            }
        }
    }
 
    // Function for display the matrix
    static void printMatrix(int[, ] arr)
    {
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++)
                Console.Write(arr[i, j] + " ");
            Console.WriteLine();
        }
    }
 
    // Function to anticlockwise
    // rotate matrix by 180 degree
    static void rotate180(int[, ] arr)
    {
        transpose(arr);
        reverseColumns(arr);
        transpose(arr);
        reverseColumns(arr);
    }
 
    // Driver Code
    static public void Main()
    {
        int[, ] arr = { { 1, 2, 3, 4 },
                        { 5, 6, 7, 8 },
                        { 9, 10, 11, 12 },
                        { 13, 14, 15, 16 } };
 
        rotate180(arr);
        printMatrix(arr);
    }
}
 
// This code is contributed by ajit

Python3

# Python3 program for left rotation of matrix by 180
  
R = 4
C = 4
  
# Function to rotate the matrix by 180 degree
def reverseColumns(arr):
    for i in range(C):
        j = 0
        k = C-1
        while j < k:
            t = arr[j][i]
            arr[j][i] = arr[k][i]
            arr[k][i] = t
            j += 1
            k -= 1
             
# Function for transpose of matrix
def transpose(arr):
    for i in range(R):
        for j in range(i, C):
            t = arr[i][j]
            arr[i][j] = arr[j][i]
            arr[j][i] = t
  
# Function for display the matrix
def printMatrix(arr):
    for i in range(R):
        for j in range(C):
            print(arr[i][j], end = " ");
        print();
  
# Function to anticlockwise rotate matrix
# by 180 degree
def rotate180(arr):
    transpose(arr);
    reverseColumns(arr);
    transpose(arr);
    reverseColumns(arr);
  
# Driven code
arr = [ [ 1, 2, 3, 4 ],
        [ 5, 6, 7, 8 ],
        [9, 10, 11, 12 ],
        [13, 14, 15, 16 ] ];
rotate180(arr);
printMatrix(arr);

输出 ：

16 15 14 13 
 12 11 10 9 
 8 7 6 5 
 4 3 2 1

时间复杂度： O(R * C)
辅助空间： O(1)
在上面的代码中，矩阵的转置必须被找到两次，并且列必须被反转两次。
因此，我们可以有一个更好的解决方案。

方法：3(位置交换)
在这里，我们交换各个位置的值。

C++

#include 
using namespace std;
 
/**
 * Reverse Row at specified index in the matrix
 * @param data matrix
 * @param index row index
 */
void reverseRow(vector>& data,
                int index)
{
    int cols = data[index].size();
    for(int i = 0; i < cols / 2; i++)
    {
        int temp = data[index][i];
        data[index][i] = data[index][cols - i - 1];
        data[index][cols - i - 1] = temp;
    }
}
 
/**
 * Print Matrix data
 * @param data matrix
 */
void printMatrix(vector>& data)
{
    for(int i = 0; i < data.size(); i++)
    {
        for(int j = 0; j < data[i].size(); j++)
        {
            cout << data[i][j] << " ";
        }
        cout << endl;
    }
}
 
/**
 * Rotate Matrix by 180 degrees
 * @param data matrix
 */
void rotateMatrix180(vector>& data)
{
    int rows = data.size();
    int cols = data[0].size();
 
    if (rows % 2 != 0)
    {
         
        // If N is odd reverse the middle
        // row in the matrix
        reverseRow(data, data.size() / 2);
    }
     
    // Swap the value of matrix [i][j] with
    // [rows - i - 1][cols - j - 1] for half    
    // the rows size.
    for(int i = 0; i <= (rows/2) - 1; i++)
    {
        for(int j = 0; j < cols; j++)
        {
            int temp = data[i][j];
            data[i][j] = data[rows - i - 1][cols - j - 1];
            data[rows - i - 1][cols - j - 1] = temp;
        }
    }
}
 
// Driver code   
int main()
{
    vector> data{ { 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 } };
 
    // Rotate Matrix
    rotateMatrix180(data);
 
    // Print Matrix
    printMatrix(data);
 
    return 0;
}
 
// This code is contributed by divyeshrabadiya07

Java

public class GFG {
       /**
     * Reverse Row at specified index in the matrix
     * @param data matrix
     * @param index row index
     */
    private static void reverseRow(int[][] data, int index) {
        int cols = data[index].length;
        for (int i = 0; i < cols / 2; i++) {
            int temp = data[index][i];
            data[index][i] = data[index][cols - i - 1];
            data[index][cols - i - 1] = temp;
        }
    }
 
    /**
     * Print Matrix data
     * @param data matrix
     */
    private static void printMatrix(int[][] data) {
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
                System.out.print(data[i][j] + " ");
            }
            System.out.println("");
        }
    }
 
    /**
     * Rotate Matrix by 180 degrees
     * @param data matrix
     */
    private static void rotateMatrix180(int[][] data) {
        int rows = data.length;
        int cols = data[0].length;
 
        if (rows % 2 != 0) {
            //If N is odd reverse the middle row in the matrix
            reverseRow(data, data.length / 2);
        }
 
        //Swap the value of matrix [i][j] with [rows - i - 1][cols - j - 1] for half the rows size.
        for (int i = 0; i <= (rows/2) - 1; i++) {
            for (int j = 0; j < cols; j++) {
                int temp = data[i][j];
                data[i][j] = data[rows - i - 1][cols - j - 1];
                data[rows - i - 1][cols - j - 1] = temp;
            }
        }
    }
 
    public static void main(String[] args) {
        int[][] data = {
                {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}
        };
 
        //Rotate Matrix
        rotateMatrix180(data);
 
        //Print Matrix
        printMatrix(data);
    }
}

Python3

# Reverse Row at specified index in the matrix
def reverseRow(data, index):
     
    cols = len(data[index])
    for i in range(cols // 2):
        temp = data[index][i]
        data[index][i] = data[index][cols - i - 1]
        data[index][cols - i - 1] = temp
     
    return data
 
# Print Matrix data
def printMatrix(data):
     
    for i in range(len(data)):
        for j in range(len(data[0])):
            print(data[i][j], end = ' ')
         
        print()
 
# Rotate Matrix by 180 degrees
def rotateMatrix(data):
     
    rows = len(data)
    cols = len(data[0])
     
    if (rows % 2):
         
        # If N is odd reverse the middle
        # row in the matrix
        data = reverseRow(data, len(data) // 2)
         
        # Swap the value of matrix [i][j] with
        # [rows - i - 1][cols - j - 1] for half
        # the rows size.
        for i in range(rows // 2):
            for j in range(cols):
                temp = data[i][j]
                data[i][j] = data[rows - i - 1][cols - j - 1]
                data[rows - i - 1][cols - j - 1] = temp
         
        return data
         
# Driver Code
data = [ [ 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 ] ]
          
# Rotate Matrix
data = rotateMatrix(data)
 
# Print Matrix
printMatrix(data)
 
# This code is contributed by rohitsingh07052

C＃

using System;
 
class GFG
{
  /**
     * Reverse Row at specified index in the matrix
     * @param data matrix
     * @param index row index
     */
  private static void reverseRow(int[, ] data, int index)
  {
    int cols = data.GetLength(1);
    for (int i = 0; i < cols / 2; i++)
    {
      int temp = data[index, i];
      data[index, i] = data[index, cols - i - 1];
      data[index, cols - i - 1] = temp;
    }
  }
 
  /**
     * Print Matrix data
     * @param data matrix
     */
  private static void printMatrix(int[, ] data)
  {
    for (int i = 0; i < data.GetLength(0); i++)
    {
      for (int j = 0; j < data.GetLength(1); j++)
      {
        Console.Write(data[i, j] + " ");
      }
      Console.WriteLine();
    }
  }
 
  /**
     * Rotate Matrix by 180 degrees
     * @param data matrix
     */
  private static void rotateMatrix180(int[, ] data)
  {
    int rows = data.GetLength(0);
    int cols = data.GetLength(1);
 
    if (rows % 2 != 0)
    {
 
      // If N is odd reverse the middle row in the
      // matrix
      reverseRow(data, data.GetLength(0) / 2);
    }
 
    // Swap the value of matrix [i][j] with [rows - i -
    // 1][cols - j - 1] for half the rows size.
    for (int i = 0; i <= (rows / 2) - 1; i++)
    {
      for (int j = 0; j < cols; j++)
      {
        int temp = data[i, j];
        data[i, j] = data[rows - i - 1, cols - j - 1];
        data[rows - i - 1, cols - j - 1] = temp;
      }
    }
  }
 
  // Driver code
  public static void Main()
  {
    int[, ] data = { { 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 } };
 
    // Rotate Matrix
    rotateMatrix180(data);
 
    // Print Matrix
    printMatrix(data);
  }
}
 
// This code is contributed by subhammahato348

输出 ：

25 24 23 22 21 
20 19 18 17 16 
15 14 13 12 11 
10 9 8 7 6 
5 4 3 2 1 

时间复杂度： O(R * C)
辅助空间： O(1)