如何將N×N矩陣旋轉90度？

Question

如何將N×N矩陣旋轉90度。我想要它在現場？

Answer 1

for(int i=0; i<n/2; i++) 
    for(int j=0; j<(n+1)/2; j++) 
     cyclic_roll(m[i][j], m[n-1-j][i], m[n-1-i][n-1-j], m[j][n-1-i]); 


void cyclic_roll(int &a, int &b, int &c, int &d) 
{ 
    int temp = a; 
    a = b; 
    b = c; 
    c = d; 
    d = temp; 
} 

注意我沒有測試過這，現在就在現場進行組合。在做任何事情之前請先測試一下。

Answer 2

您可以創建第二個數組，然後將第一個數組複製到第二個數組中，方法是讀取第一個數組中的row-major並將column-major寫入第二個數組中。

所以，你會複製：

1 2 3 
4 5 6 
7 8 9 

，你會讀，然後在第一行寫回了首發，如：

3 
2 
1 

Answer 3

這是我的溶液： （旋轉PI/2的順時針方向）

1. 做陣列的轉置，（如矩陣轉置）

2. 反向每行

   元素

   cons int row = 10; 
   cons int col = 10; 
   //transpose 
   for(int r = 0; r < row; r++) { 
       for(int c = r; c < col; c++) { 
       swap(Array[r][c], Array[c][r]); 
       } 
   } 
   //reverse elements on row order 
   for(int r = 0; r < row; r++) { 
       for(int c =0; c < col/2; c++) { 
        swap(Array[r][c], Array[r][col-c-1]) 
       } 
   } 
   

if if pi/2逆時針旋轉

1. 轉置陣

2. 逆轉列順序

從未測試代碼的元素！ 任何建議，將不勝感激！

Answer 4

一個完整的C程序，說明了我的方法。本質上它是遞歸算法。在每次遞歸時，旋轉外層。當你的矩陣是1x1或0x0時停止。

#include <stdio.h> 

int matrix[4][4] = { 
    {11, 12, 13, 14}, 
    {21, 22, 23, 24}, 
    {31, 32, 33, 34}, 
    {41, 42, 43, 44} 
}; 

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

int *get(int offset, int x, int y) 
{ 
    return &matrix[offset + x][offset + y]; 
} 

void transpose(int offset, int n) 
{ 
    if (n > 1) { 
     for (int i = 0; i < n - 1; i++) { 
     int *val1 = get(offset, 0, i); 
     int *val2 = get(offset, i, n - 1); 
     int *val3 = get(offset, n - 1, n - 1 - i); 
     int *val4 = get(offset, n - 1 - i, 0); 

     int temp = *val1; 
     *val1 = *val4; 
     *val4 = *val3; 
     *val3 = *val2; 
     *val2 = temp; 
     } 

     transpose(offset + 1, n - 2); 
    } 
} 

main(int argc, char *argv[]) 
{ 
    print_matrix(4); 
    transpose(0, 4); 
    print_matrix(4); 
    return 0; 
} 

Answer 5

//Java version, fully tested 

public class Rotate90degree { 


     public static void reverseElementsRowWise(int[][] matrix) { 
      int n = matrix.length; 
      for(int i = 0; i < n; ++i) { 
       for(int j = 0; j < n/2; ++j) { 
        int temp = matrix[i][n - j - 1]; 
        matrix[i][n - j - 1] = matrix[i][j]; 
        matrix[i][j] = temp; 
       } 
      } 
     } 

     public static void transpose(int[][] matrix) { 
      int n = matrix.length; 
      for(int i = 0; i < n; ++i) { 
       for(int j = i + 1; j < n; ++j) { 
        int temp = matrix[i][j]; 
        matrix[i][j] = matrix[j][i]; 
        matrix[j][i] = temp; 
       } 
      } 
     } 

     public static void rotate90(int[][] matrix) { 
      transpose(matrix); 
      reverseElementsRowWise(matrix); 
     } 

     public static void print(int[][] matrix) { 
      int n = matrix.length; 
      for(int i = 0; i < n; ++i) { 
       for(int j = 0; j < n; ++j) { 
        System.out.print(matrix[i][j]); 
        System.out.print(' '); 
       } 
       System.out.println(); 
      } 
     } 

     public static void main(String[] args) { 
      int[][] matrix = { 
        {1, 2, 3, 4}, 
        {5, 6, 7, 8}, 
        {9, 10, 11, 12}, 
        {13, 14, 15, 16}}; 
      System.out.println("before"); 
      print(matrix); 
      rotate90(matrix); 
      System.out.println("after"); 
      print(matrix); 
     } 
}