顺时针旋转数组

Question

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

public int[][] rotateArray(int[][] arr) {
    // first change the dimensions vertical length
    // for horizontal length and vice versa
    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;
}

Answer 1

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

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;
}

请注意以下几点：

• 将 MxN 矩阵的维度表示为 M 和 N 可以提高可读性
• 传统上使用 r, c 而不是 i, j 来索引矩阵的行和列
• 这不是最强大的实现：
  • 不确保 mat 是有效的 MxN 矩阵，M>0, N>0
• 使用显式映射公式而不是无关的局部变量
  • 使程序更简单且更具可读性

这是一个测试工具：

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]
}

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

Java 矩阵库的链接

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

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

相关问题

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

• 数组数组与多维数组的性能比较
• < a href="https://stackoverflow.com/questions/2721033/java-arrays-equals-returns-false-for-two-Dimension-arrays">Java Arrays.equals() 返回 < code>false 对于二维数组。

Answer 2

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

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

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

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

Answer 3

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

尝试在外循环中重置jj。

Answer 4

通用对象的解决方案：

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;
}

用法：

rotateArray90clockwise(Some.class,array);

Answer 5

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;
}

Answer 6

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);
    }
}

Answer 7

我完全理解这个问题与 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)
    }

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

Answer 8

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

1. 对给定矩阵交换列进行垂直转置
2. （如果您想要顺时针旋转）
   （或）

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

顺时针旋转程序：

//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");
        }
    }
}

逆时针旋转程序

//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 = 行数或列数

，我们可以在其中更改 n，以上仅适用于

经过测试且运行良好的方阵

Answer 9

这是我经过验证的解决方案：

public int[][] rotateImage(int[][] a) {
    int colLenght = a[0].length;
    int rowLength = a.length;
    int[][] r = new int[rowLength][colLenght];

    for (int i = 0; i < a.length; i++) {
        for (int j = a.length - 1, rc = 0; j >= 0 && rc < a.length; j--, rc++) {
            r[i][rc] = a[j][i];
        }
    }
    return r;
}

Answer 10

int[] a = new int[]{10, 20, 30, 40, 50};
int temp = a[a.length - 1];
for (int i = a.length - 1; i > 0; i--) {
    a[i] = a[i - 1];
}
for (int i = 0; i < a.length; i++) {
    a[0] = temp;
    System.out.println("" + a[i]);
}

Answer 11

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;

    }
}