顺时针旋转阵列

时间：2010-05-10 00:36:52

标签： java algorithm arrays

我有一个二维数组，我需要顺时针旋转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;
    }

10 个答案:

答案 0 :(得分：37)

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

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矩阵库的链接

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

相关问题

从技术上讲，Java有阵列数组。确保你了解所有影响。

答案 1 :(得分：14)

我不理解你的循环逻辑 - 不应该是

   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一样下降（以及是否需要在分配中“翻转”，例如使用{{ 1}}代替arr.length-1-j在作业中的j的一侧{ - 1}};因为=尺寸为arr arr.length，并且反之亦然arr[0].length，在我看来，newArray上的第一个索引（arr上的第二个索引）必须是涵盖0到newArray范围的索引，并且另一个指数的另一个范围。

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

答案 2 :(得分：3)

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

尝试在外循环中重置jj。

答案 3 :(得分：1)

通用对象的解决方案：

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

答案 4 :(得分：1)

public function setStartAttribute($value) { }

答案 5 :(得分：0)

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

答案 6 :(得分：0)

*顺时针旋转矩阵或逆时针旋转

的步骤

1.取得给定矩阵的转置 2.垂直切换列（如果需要顺时针旋转） （OR）

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

顺时针旋转程序

//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，以上内容仅适用于方形矩阵

经过测试和工作

答案 7 :(得分：0)

我完全明白这个问题与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中搜索问题时，此线程或其他弹出的内容。

答案 8 :(得分：0)

这是我已验证的解决方案：

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

答案 9 :(得分：-2)

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;

    }
}
相关问题
最新问题