Java 顺时针旋转阵列

我有一个二维数组，我需要顺时针旋转90度，但我一直在得到数组索引

public int[]]rotatarray（int[]]arr）{
//首先更改垂直长度的尺寸标注
//对于水平长度，反之亦然
int[]newArray=newint[arr[0].length][arr.length]；
//通过启动将值逆时针旋转90度
//从阵列的按钮到顶部，从左到右
int ii=0；
int jj=0；
对于（int i=0；i=0；j--）{
newArray[ii][jj]=arr[i][j]；
jj++；
}
ii++；
}
返回新数组；
}
jj++
运行了
i*j
次，这一点都不好

试着在外循环中重置jj。
我不理解你的循环逻辑——应该是吗

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

for（int i=0；i=0；j--）{
newArray[i][j]=arr[j][i]；
}
}

扣除每个索引是向上，如此处的
i
，还是向下，如此处的
j
（以及是否需要在赋值中“翻转”其中一个或两个，例如在赋值中使用
arr.length-1-j
代替
=/code>一侧的普通
j
；-），由于
arr
维度是
arr.length
的
arr[0]。length
，而
newArray
的维度也是
arr.length
的维度，因此在我看来
arr
上的第一个索引（第二个在
newArray
上）必须是包含范围从0到
arr.length-1
的索引，另一个范围是另一个指数

这是一种“基本维度分析”（除了“维度”的使用与“维度分析”的通常含义不同，后者指的是物理维度，即时间、质量、长度和c；-）。“翻转”和每个循环向上或向下的问题取决于你的意思，而我并不是最伟大的“心理可视化者”，所以我认为，在现实生活中，我会尝试各种不同的“轴变换”，直到我找到了它的意思；-）
 这是一个标准的矩阵顺时针旋转代码：

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

注意循环和在
printMatrix
中的使用。如果您在Java中经常使用数组，那么您肯定应该熟悉它们

指向Java矩阵库的链接
如果你使用矩阵很多，你可能想考虑使用一个专门的矩阵库来代替。

贾马：
UJMP：

相关问题
从技术上讲，Java具有数组数组。确保你理解所有的含义




公共类旋转矩阵{
行的静态int索引；
_列的静态int索引_；
静态整数行数；
_列的静态int数_；
公共静态void main（字符串[]args）{
int[][]矩阵={{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}};
行的索引=matrix.length-1；
_列的索引_=矩阵[0]。长度-1；
行数=矩阵长度；
列数=矩阵[0]。长度；
RotateMatrix rm=新的RotateMatrix（）；
rm.printGrid（矩阵）；//旋转前
rm.旋转360CW（矩阵，rm）；
}
公共整数[][]旋转90CW（整数[][]矩阵，旋转矩阵rm）{
int[][]newMatrix=新int[行数][列数]；
int totalNumber=（行数）*（列数）；
int[]intArray=createSingleArray（矩阵，总数）；
int a=0；
//保持索引不出现越界错误；修改为：
//_列的数量\u-1
//行数\u-1
对于（int c=列数-1；c>=0；c--）{
对于（int r=0；r
public类示例{
/**
*@param args
*/
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
int mat[][]={{1,2,3}，{4,5,6}，{7,8,9}，{10,11,12}；
打印矩阵（mat）；
int反锁矩阵[][]=旋转反锁矩阵（mat）；
打印矩阵（反锁矩阵）；
int clockwiseMatrix[][]=旋转clockwiseMatrix（mat）；
打印矩阵（时钟矩阵）；
//旋转刺激矩阵（mat）；
}
公共静态void打印矩阵（int mat[]]{
对于（int i=0；i=0；j--）{
finMat[i][n]=newMat[i][j]；
n++；
}
}
返回finMat；
}
}
通用对象的解决方案：

publicstatict[]T[]rotatarray90顺时针旋转（类clas，T[]array）{
T[][]目标=（T[][]）java.lang.reflect.Array.newInstance(
clas，数组[0]。长度，数组。长度）；
for（int i=0；i

用法：
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]
}

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

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;

    }
}

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