Question

我有一个2D矩阵M [N] [N]我需要逆时针旋转90度。我已经看到许多顺时针旋转的答案，但我找不到逆时针。两个操作有多相似？

Answer 1

如果颠倒每一行的顺序，然后从顺时针旋转中按相反顺序拍摄行，则会得到顺时针旋转的顺序。

A B C                  G D A               A D G                  C F I
D E F -> Clockwise ->  H E B -> Reverse -> B E H  -> Opposite ->  B E H
G H I                  I F C    Rows       C F I     Ordering     A D G

Matrix                                                            Counter
                                                                  Clockwise

如果您已经有一个顺时针旋转算法，通常以相反的顺序在原始矩阵上进行顺时针旋转旋转会更容易（并且计算效率更高）。

1 2 3                9 8 7                 3 6 9
4 5 6 -> Reverse  -> 6 5 4 -> Clockwise -> 2 5 8
7 8 9    Indices     3 2 1                 1 4 7

Matrix                                     Counter
                                           Clockwise

您也可以顺时针旋转3圈进行逆时针旋转。

虽然实际上直接编辑顺时针算法通常很容易。因此，如果您不关心效率并且不想通过改变旋转方向的逻辑，我只会使用上述选项。

Answer 2

从行（max）开始递减，用该列的值逐个填充结果行（递增索引），一个接一个地递增（递增）。

所以在3 x 3中，使用（使用r，c表示法，如Excel）

（3,1），（3,2），（3,3），（2,1），（2,2），（2,3），

等

Answer 3

行。让我们说N =2很简单：

1  2
3  4

逆时针90度表示它将成为：

2 4
1 3

我们有以下规则：

1 last column from top to bottom of original matrix becomes 
  first row of rotated matrix from left to right
2 first column of original matrix becomes last row of rotated matrix
3 same rules apply to other columns of original matrix

您可以轻松编写代码。另一种方法是先在矩阵上进行转置，然后颠倒所有行的顺序。

Answer 4

如果您使用的是特定的矩阵库，则可以进行3次转置

Answer 5

public static void main(String[] args) {
    int[][] matrix = createAMatrix(3,3);
    List<Stack<Integer>> tiltedMatrix = tiltMatrixBy90Now(matrix, 3);

    int[][] newMatrix = new int[3][3];

    for(int i = 0; i < 3; i ++) {
        for(int j = 0; j < 3; j ++) {
            newMatrix[i][j] = tiltedMatrix.get(j).pop();
        }
    }
    //print new matrix
    for(int i = 0; i < 3; i ++) {
        for(int j = 0; j < 3; j ++) {
            System.out.print(newMatrix[i][j]+" ");
        }
        System.out.println();
    }

}


private static List<Stack<Integer>> tiltMatrixBy90Now(int[][] matrix , long order) {
    List<Stack<Integer>> stackList = new ArrayList<>();
    //filling the stack
    for(int i = 0; i< order ; i++) {
        stackList.add(new Stack<Integer>());
    }

    for(int i = 0; i < order; i ++) {
        for(int j = 0; j < order; j ++) {
            stackList.get(i).push(matrix[i][j]);
        }
    }
    return stackList;
}
private static int[][] createAMatrix(final int a, final int b){
    int counter = 1;
    int[][] matrix  = new int[a][b];
    Scanner scanner = new Scanner(System.in);
    while(counter <= a*b) {
        for(int i = 0; i < a; i ++) {
            for(int j = 0; j < b; j ++) {
                matrix[i][j] = scanner.nextInt();
                counter++;
            }
        }
    }
    return matrix;
}

/ *

输入矩阵（3乘3） 1 2 3 4 5 6 7 8 9

输出矩阵（3乘3）： 3 6 9 2 5 8 1 4 7

作为文本解释的代码演练

在上面的代码中创建一个矩阵，它是3 * 3矩阵
从3 * 3矩阵的每一行创建3个堆栈
并行地从每个堆栈中弹出，然后重新创建矩阵。
以90度（逆时针）打印新的倾斜矩阵。

* /

旋转NxN矩阵计数器（antiClockwise 90 Degrees

5 个答案: