Java 顺时针旋转阵列

Rotate array clockwise

提问by user69514

I have a two dimensional array that I need to rotate 90 degrees clockwise, however I keep getting arrayindexoutofbounds...

我有一个二维数组，我需要顺时针旋转 90 度，但是我不断收到 arrayindexoutofbounds ......

public int[][] rorateArray(int[][] arr){

        //first change the dimensions vertical length for horizontal length
        //and viceversa
        int[][] newArray = new int[arr[0].length][arr.length];

        //invert values 90 degrees clockwise by starting from button of
        //array to top and from left to right
        int ii = 0;
        int jj = 0;
        for(int i=0; i<arr[0].length; i++){
            for(int j=arr.length-1; j>=0; j--){
                newArray[ii][jj] = arr[i][j];

                jj++;
            }
            ii++;
        }

        return newArray;
    }

采纳答案by Alex Martelli

I don't understand your loops' logic -- shouldn't it be

我不明白你的循环逻辑——不应该是

   for(int i=0; i<arr[0].length; i++){
        for(int j=arr.length-1; j>=0; j--){
            newArray[i][j] = arr[j][i];
        }
    }

Net of whether each index goes up, like ihere, or down, like jhere (and of whether either or both need to be "flipped" in the assignment, e.g using arr.length-1-jin lieu of plain jon one side of the =in the assignment;-), since arrdimensions are arr.lengthby arr[0].length, and vice versa for newArray, it seems to me that the first index on arr(second on newArray) must be the one spanning the range from 0 to arr.length-1included, and the other range for the other index.

每个索引是上升，像i这里，还是下降，像j这里（以及是否需要在分配中“翻转”其中一个或两个，例如arr.length-1-j在分配的j一侧使用代替普通=；-) ，因为arr维度是arr.lengthby arr[0].length，反之亦然newArray，在我看来，arr（第二个 on newArray）上的第一个索引必须跨越从 0 到arr.length-1包含的范围，另一个范围是另一个索引。

This is a kind of "basic dimensional analysis" (except that "dimension" is used in a different sense than normally goes with "dimensional analysis" which refers to physical dimensions, i.e., time, mass, length, &c;-). The issue of "flipping" and having each loop go up or down depend on visualizing exactly what you mean and I'm not the greatest "mental visualizer" so I think, in real life, I'd try the various variants of this "axis transposition" until I hit the one that's meant;-).

这是一种“基本量纲分析”（除了“量纲”的使用意义不同于“量纲分析”通常指的物理量纲，即时间、质量、长度等）。“翻转”和让每个循环上升或下降的问题取决于准确地形象化你的意思，我不是最伟大的“心理形象化者”，所以我想，在现实生活中，我会尝试这个的各种变体“轴换位”，直到我击中那个意思；-)。

回答by Jens Bj?rnhager

jj++ is run i*j times, and that can't be good at all.

jj++ 运行 i*j 次，这根本不好。

Try to reset jj in the outer loop.

尝试在外循环中重置 jj。

回答by polygenelubricants

Here's a standard matrix clockwise rotation code:

这是一个标准矩阵顺时针旋转代码：

static int[][] rotateCW(int[][] mat) {
    final int M = mat.length;
    final int N = mat[0].length;
    int[][] ret = new int[N][M];
    for (int r = 0; r < M; r++) {
        for (int c = 0; c < N; c++) {
            ret[c][M-1-r] = mat[r][c];
        }
    }
    return ret;
}

Note a few things:

请注意以下几点：

• It improves readability to refer to the dimensions of a MxNmatrix as Mand N
• It's traditional to use r, cinstead of i, jto index row and column of a matrix
• This is not the most robust implementation:
  • Does not ensure that matis a valid MxNmatrix, M>0, N>0
• Use an explicit mapping formula instead of extraneous local variables
  • Makes program less complex and more readable

• 将MxN矩阵的维度称为M和N
• 传统上使用r, c而不是i, j索引矩阵的行和列
• 这不是最健壮的实现：
  • 不确保这mat是一个有效的MxN矩阵，M>0, N>0
• 使用显式映射公式而不是无关的局部变量
  • 使程序更简单，更易读

Here's a test harness:

这是一个测试工具：

import java.util.Arrays;
//...

static void printMatrix(int[][] mat) {
    System.out.println("Matrix = ");
    for (int[] row : mat) {
        System.out.println(Arrays.toString(row));
    }
}
public static void main(String[] args){
    int[][] mat = {
        { 1, 2, 3 },
        { 4, 5, 6 }
    };
    printMatrix(mat);
    // Matrix = 
    // [1, 2, 3]
    // [4, 5, 6]

    int[][] matCW = rotateCW(mat);
    printMatrix(matCW);
    // Matrix = 
    // [4, 1]
    // [5, 2]
    // [6, 3]
}

Note the use of the for-eachloop and java.util.Arraysin printMatrix. You should definitely familiarize yourself with them if you're working with arrays a lot in Java.

注意for-each循环和java.util.Arraysin 的使用printMatrix。如果您经常在 Java 中使用数组，那么您绝对应该熟悉它们。

Links to Java matrix libraries

Java 矩阵库的链接

If you're working with matrices a lot, you may want to consider using a specialized matrix library instead.

如果您经常使用矩阵，则可能需要考虑使用专门的矩阵库。

• JAMA: http://math.nist.gov/javanumerics/jama/
• UJMP: http://www.ujmp.org/

• 美国医学会：http: //math.nist.gov/javanumerics/jama/
• UJMP：http://www.ujmp.org/

Related questions

相关问题

Technically, Java has array of arrays. Make sure you understand all the implications.

从技术上讲，Java 有数组数组。确保您了解所有含义。

• Performance comparison of array of arrays vs multidimensional arrays
• Java Arrays.equals()returns falsefor two dimensional arrays.

• 数组数组与多维数组的性能比较
• JavaArrays.equals()返回false二维数组。

回答by willyconnor

public class RotateMatrix {

    static int index_of_rows;
    static int index_of_columns;
    static int number_of_rows;
    static int number_of_columns;

    public static void main(String[] args) {
        int[][] matrix={{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}};
        index_of_rows = matrix.length -1;
        index_of_columns = matrix[0].length -1;
        number_of_rows = matrix.length;
        number_of_columns = matrix[0].length;


        RotateMatrix rm = new RotateMatrix();

        rm.printGrid(matrix);//before rotation
        rm.rotate360CW(matrix,rm);

    }

    public int[][] rotate90CW(int[][] matrix, RotateMatrix rm) {

        int[][] newMatrix = new int[number_of_rows][number_of_columns];
        int totalNumber = (number_of_rows) * (number_of_columns);
        int[] intArray = createSingleArray(matrix,totalNumber);


        int a =0;
            // kept index from out-of-bounds error; mod to:
            // number_of_columns-1
            // number_of_rows-1
        for(int c=number_of_columns-1; c>=0; c--) {
            for(int r=0; r<=number_of_rows-1; r++) {
                newMatrix[r][c] = intArray[a];
                a++;
            }
        }
        rm.printGrid(newMatrix);
        return newMatrix;
    }

    public int[] createSingleArray(int[][] matrix, int totalNumber) {
        int a=0;
        int[] intArray = new int[totalNumber];

        for(int b=0;b<=index_of_rows; b++) {
            for(int c=0; c<=index_of_columns;c++) {
                intArray[a] = matrix[b][c];
                a++;
            }
        }
        return intArray;
    }

    public void printGrid(int[][] matrix) {
        StringBuilder sb = new StringBuilder("--------------------------");

        for(int i =0; i<=index_of_rows; i++) {
            System.out.println(sb.toString());//print each row
            sb.delete(0, sb.length());//Then clear the row and build the next
            for(int j=0; j<=index_of_columns;j++) {
                sb.append(matrix[i][j]+",");
            }
        }
        System.out.println(sb.toString());

    }

    public int[][] rotate180CW(int[][] matrix, RotateMatrix rm) {
        return rm.rotate90CW(rm.rotate90CW(matrix, rm), rm);
    }

    public int[][] rotate270CW(int[][] matrix, RotateMatrix rm) {
        return rm.rotate90CW(rm.rotate90CW(rm.rotate90CW(matrix, rm), rm),rm);
    }

    public int[][] rotate360CW(int[][] matrix, RotateMatrix rm) {
        return rm.rotate90CW(rm.rotate90CW(rm.rotate90CW(rm.rotate90CW(matrix, rm),
                                                    rm),rm),rm);
    }
}

回答by Ashwini Kaushik

public class Sample {

    /**
     * @param args
     */

    public static void main(String[] args) {
        // TODO Auto-generated method stub      
        int mat[][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }, { 10, 11, 12 } };
        printMatrix(mat);

        int antiClockwiseMatrix[][] = rotateAntiClockwiseMatrix(mat);
        printMatrix(antiClockwiseMatrix);
        int clockwiseMatrix[][] = rotateClockwiseMatrix(mat);
        printMatrix(clockwiseMatrix);

        // rotateAntiMatrix(mat);
    }

    public static void printMatrix(int mat[][]) {
        for (int i = 0; i < mat.length; i++) {
            for (int j = 0; j < mat[0].length; j++) {
                System.out.print(mat[i][j] + "\t");
            }
            System.out.print("\n");
        }
        System.out.print("\n");

    }

    static public int[][] rotateAntiClockwiseMatrix(int mat[][]) {
        int rows = mat.length;
        int cols = mat[0].length;
        int newMat[][] = new int[cols][rows];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                newMat[j][i] = mat[i][j];
            }
        }

        return newMat;
    }

    static public int[][] rotateClockwiseMatrix(int mat[][]) {
        int newMat[][] = rotateAntiClockwiseMatrix(mat);
        int finMat[][] = new int[newMat.length][newMat[0].length];
        for (int i = 0; i < newMat.length; i++) {
            int n = 0;
            for (int j = newMat[0].length - 1; j >= 0; j--) {
                finMat[i][n] = newMat[i][j];
                n++;
            }
        }

        return finMat;

    }
}

回答by Mickey Tin

Solution for generic objects:

通用对象的解决方案：

 public static <T> T[][] rotateArray90clockwise(Class<T> clas, T[][] array){

        T[][] target = (T[][])java.lang.reflect.Array.newInstance(clas, array[0].length, array.length);

        for (int i = 0; i < target.length; i++) {
            for (int j = 0; j < target[i].length; j++) {
                target[i][j] = array[(target[i].length - 1) - j][i];
            }
        }

        return target;
    }

usage:

用法：

rotateArray90clockwise(Some.class,array);

回答by Feelings Baby

*Steps to Rotate a matrix clockwise or Anti-Clockwise

*顺时针或逆时针旋转矩阵的步骤

1.Take Transpose of Given Matrix 2.Swap columns vertical (if you want Clockwise Rotation) (OR)

1.Take Transpose of Given Matrix 2.Swap 列垂直（如果你想要顺时针旋转）（或）

Swap Columns Horizontal (if You want Anti-Clockwise Rotation)*

水平交换列（如果您想要逆时针旋转）*

Program For Clockwise Rotation

顺时针旋转程序

//Program For Clockwise Rotation
import java.util.Scanner;

public class ClockWiseRotation {
    public static void main(String[] args)
    {
        int i,j,sw,n=4;
        int a[][]=new int[6][6];
        int b[][]=new int[6][6];
        System.out.println("Enter the  elements for matrix\n");
        Scanner input = new Scanner(System.in);
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                a[i][j] =input.nextInt();
            }
        }

        System.out.println("The Matrix\n");

        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                System.out.print(a[i][j]+"\t");
            }
            System.out.println("\n");
        }

        System.out.println("Transformation of given matrix\n");
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
              b[i][j]=a[j][i];
            }
        }

        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                System.out.print(b[i][j]+"\t");
            }
            System.out.println("\n");
        }

        System.out.println("Clockwise Rotation of given matrix\n");

        for(i=0;i<n/2;i++)
        {
            for(j=0;j<n;j++)
            {

                sw=b[j][i];
                b[j][i]=b[j][n-1-i];
                b[j][n-1-i]=sw;
            }
            System.out.println("\n");
        }



        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                System.out.print(b[i][j]+"\t");
            }
            System.out.println("\n");
        }

    }
}

Program For Anti-Clockwise Rotation

逆时针旋转程序

//Anti-Clockwise Rotation

import java.util.Scanner;

public class Anti_ClockWiseRotation {
    public static void main(String[] args)
    {
        int i,j,sw,n=6;
        int a[][]=new int[6][6];
        int b[][]=new int[6][6];
        System.out.println("Enter the  elements for matrix\n");
        Scanner input = new Scanner(System.in);
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                a[i][j] =input.nextInt();
            }
        }

        System.out.println("The Matrix\n");

        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                System.out.print(a[i][j]+"\t");
            }
            System.out.println("\n");
        }

        System.out.println("Transformation of given matrix\n");
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
              b[i][j]=a[j][i];
            }
        }

        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                System.out.print(b[i][j]+"\t");
            }
            System.out.println("\n");
        }

        System.out.println("Anti-Clockwise Rotation of given matrix\n");

        for(i=0;i<n;i++)
        {
            for(j=0;j<n/2;j++)
            {

                sw=b[j][i];
                b[j][i]=b[n-1-j][i];
                b[n-1-j][i]=sw;

            }
            System.out.println("\n");
        }



        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                System.out.print(b[i][j]+"\t");
            }
            System.out.println("\n");
        }

    }
}

n = Number of rows or Number of Columns

n = 行数或列数

Where We can change the n , The above are worked only for square Matrix

我们可以在哪里更改 n ，以上仅适用于方阵

Tested and Worked Well

经过测试并运行良好

回答by bearacuda13

I completely understand that this question has nothing to do with Swift, but here's some verbose Swift 4:

我完全理解这个问题与 Swift 无关，但这里有一些冗长的Swift 4：

    func clockwise(num:Int, square:[[Int]]) -> [[Int]] {
        var s = square
        if num == 0 {
            return s
        }
        for x in 0...(square.count - 1) {
            for y in 0...(square.count - 1) {
                s[x][y] = square[(square.count - 1) - y][x]
            }
        }
        return clockwise(num: num - 1, square: s)
    }
    func counterClockwise(num:Int, square:[[Int]]) -> [[Int]] {
        var s = square
        if num == 0 {
            return s
        }
        for x in 0...(square.count - 1) {
            for y in 0...(square.count - 1) {
                s[x][y] = square[y][(square.count - 1) - x]
            }
        }
        return counterClockwise(num: num - 1, square: s)
    }

This thread or whatever popped up when I searched for the question in Swift.

当我在 Swift 中搜索问题时，会弹出这个线程或其他任何内容。

回答by Nitesh

    static int[][] rotateClockwise(int[][] matrix){
    int rowNum = matrix.length;
    int colNum = matrix[0].length;

    int[][] temp = new int[rowNum][colNum];
    for(int i =0; i<rowNum; i++){
        for(int j=0; j<colNum; j++){

            temp[i][j] = matrix[rowNum-j-1][i];
        }
    }
    return temp;
}