顺时针旋转数组

Question

我有一个二维数组，需要将其顺时针旋转90度，但是我一直收到“数组下标越界”的错误...

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

- user69514

---

这不是矩阵旋转，而是矩阵转置http://en.wikipedia.org/wiki/Transpose，它是沿主对角线的反射。 - polygenelubricants

这只是反转了行，但是对于每个i，jj都必须设置为0。 要旋转arr[i][j]中的i和j（不要忘记将jj设置为0）。 - Maciej Hehl

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

注意在 printMatrix 中使用了 for-each 循环和 java.util.Arrays。如果你经常使用 Java 中的数组，那么你应该一定要熟悉它们。

Java 矩阵库链接

如果你经常处理矩阵，你可能会考虑使用专门的矩阵库。

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

相关问题

技术上讲，Java 有数组的数组。确保你理解所有的含义。

• 数组的数组与多维数组性能比较
• Java 的Arrays.equals()用于二维数组会返回false

- polygenelubricants

---

如何逆时针旋转它？ - Raja Anbazhagan

这个实现为什么被称为“标准”？它是否已经在某处发布，或者这段代码应该如此简单，以至于任何不像我这样的白痴都能够快速理解？ - Zoomzoom

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）是增加还是减少，或者在赋值时需要将其进行“翻转”（例如在赋值语句中使用arr.length-1-j代替普通的j），由于arr的维度是arr.length和arr[0].length，而对于newArray则相反，因此我认为arr上的第一个索引（newArray上的第二个索引）必须跨越从0到arr.length-1范围内的那个索引，而另一个索引则在另一个范围内。

这是一种“基本的尺寸分析”（不过，“尺寸”在这里与通常用于“尺寸分析”的含义不同，它指的是物理尺寸，例如时间、质量、长度等）。翻转和循环的方向取决于准确地想象你所需的轴，而我并不是最擅长“头脑想象”的人，所以我会在现实生活中尝试各种不同的这种“轴转置”变体，直到找到正确的那一个为止。

- Alex Martelli

---

@user，不客气——我确实怀疑我在两个段落中提到的索引缺少一些翻转和/或上下颠倒的处理。;-) - Alex Martelli

newArray[i][j] = arr[j][i]; 可以将矩阵转置。应该改为：newArray[i][length-1-j] = arr[j][i]; - Maciej Hehl

@MacieJ 是正确的。查看我的回答以获得更全面的解决方案。 - polygenelubricants

Answer 3

jj++被运行了i*j次，这肯定不好。

尝试在外部循环中重置jj。

- Jens Björnhager

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

- Mickey Tin

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

- Nitesh

Answer 6

我完全理解这个问题与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 中搜索问题时，这个线程或其他内容就弹出来了。

- bearacuda13

Answer 7

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

- Youssef

---

嗨，请在您的代码中添加一些解释，以帮助OP理解它。 - Greedo

Answer 8

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

- willyconnor

Answer 9

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

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，上述仅适用于方阵

已测试并运行良好

- Feelings Baby

Answer 10

这是我的验证解决方案：

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

- M.Arun pandian