2

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

4

5 回答 5

3

如果你颠倒每一行的顺序，然后以与顺时针旋转相反的顺序取行，你会得到一个逆时针旋转。

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 圈以逆时针旋转。

尽管实际上，根据您的目的直接编辑顺时针算法通常相当容易。因此，如果您不关心效率并且不想通过改变旋转方向的逻辑来工作，我只会使用上述选项。

于 2013-04-05T16:59:48.307 回答
0

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

所以在 3 x 3 中，使用（使用 r，c 符号，如 Excel）

(3, 1), (3, 2), (3, 3), (2, 1), (2, 2), (2, 3),

等等

于 2013-04-05T16:45:54.707 回答
0

好的。让我们说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

您可以轻松地编写代码。另一种方法是首先对矩阵进行转置，然后反转所有行的顺序。

于 2013-04-05T16:49:58.960 回答
0

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

于 2013-04-05T17:00:38.933 回答
0 
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

代码演练作为文本解释

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

*/

于 2019-08-18T13:44:41.837 回答