Arrays 以同心圆旋转二维NxN矩阵_Arrays_Multidimensional Array

Arrays 以同心圆旋转二维NxN矩阵

arrays

Arrays 以同心圆旋转二维NxN矩阵,arrays,multidimensional-array,Arrays,Multidimensional Array,给定一个2D NxN矩阵，将其可视化为同心圆。您必须找到旋转矩阵，其中圆中的每个元素以交替的顺时针和逆时针方向逐层旋转1个位置。所有旋转都应到位 2 3 4 5 1 6 7 8 4 2 1 9 5 3 2 4 应该转化为 1 2 3 4 4 7 1 5 5 6 2 8 3 2 4 9 我想到了解决办法 1> 对于顺时针旋转，请按顺序读取元素 i -> 0 to n-1 and j = 0 j -> 0 to n-1 and i = n-1 i -> n-1 to 0

给定一个2D NxN矩阵，将其可视化为同心圆。您必须找到旋转矩阵，其中圆中的每个元素以交替的顺时针和逆时针方向逐层旋转1个位置。所有旋转都应到位

应该转化为

我想到了解决办法

1> 对于顺时针旋转，请按顺序读取元素

i -> 0 to n-1 and j = 0
j -> 0 to n-1 and i = n-1
i -> n-1 to 0 and j = n-1
j -> n-1 to 0 and i = 0

j -> 0 to n-1 and i = 0
i -> 0 to n-1 and j = n-1
j -> n-1 to 0 and i = n-1
i -> n-1 to 0 and j = 0

2> 对于逆时针旋转的圆圈，请按顺序读取元素

i -> 0 to n-1 and j = 0
j -> 0 to n-1 and i = n-1
i -> n-1 to 0 and j = n-1
j -> n-1 to 0 and i = 0

j -> 0 to n-1 and i = 0
i -> 0 to n-1 and j = n-1
j -> n-1 to 0 and i = n-1
i -> n-1 to 0 and j = 0

代码

for（int-cnt=0；cnt


有没有更好的方法来解决O（n2）或更好的问题？
由于数组的大小为N*N，并且所需的计算要求每个元素至少访问一次，因此没有比使用二维数组的O（N^2）
更好的解决方案了
我认为，如果操作必须在同一阵列上一次性完成，那么您的解决方案就可以了
如果必须在同一输入数组上多次执行此操作，最好从输入数组创建圆。circle的数据结构应该是CLL（循环链表）。因此，多次执行该操作将是小菜一碟，因为您必须根据方向更改存储圆圈信息的CLL的根元素。
我认为这可以在O（n）时间内轻松解决
（注：O（N），其中N是矩阵元素的总数）
以下解决方案不使用四个连续循环，而是使用一个由[X，Y]
增量组成的小表格，描述当前坐标与下一个坐标之间的差异，当下一个坐标无效（即在当前窗口之外）时，表格本身的索引将提前，并重复查找。该算法从完整窗口开始，每次嵌套循环结束时，从每侧减少一个元素。整个过程重复进行，直到定义为[minX，minY，maxX，maxY]
的窗口有效（即至少包含2x2个元素）
此解决方案不实现cw和ccw的交换，但这是最容易添加的部分

功能板（s、n）{
而（s.长度=this.w | | y<0 | | y>=this.h）
抛出新错误（“索引[“+x+”，“+y+”]超出范围”）；
返回此.data[y*this.w+x]；
}
//将值设置为[x，y]并返回上一个值。
Matrix.prototype.set=函数（x，y，值）{
如果（x<0 | | x>=this.w | | y<0 | | y>=this.h）
抛出新错误（“索引[“+x+”，“+y+”]超出范围”）；
var i=y*this.w+x；
var prev=该数据[i]；
此.data[i]=值；
返回上一个；
}
//记录矩阵数据。
Matrix.prototype.dump=函数（）{
var s=“[”
var i=0；
for（变量y=0；ymaxX|y1maxY）{
n+=2；
x1=x0+inst[n+0]；
y1=y0+inst[n+1]；
}
v0=该设定值（x1，y1，v0）；
//最后一个。
如果（x1==minX&&y1==minY）
打破
x0=x1；
y0=y1；
}
minX++；
minY++；
maxX--；
马克西--；
}
}
var a=新矩阵（3，3[
1,2,3,
4,5,6,
7,8,9,
]);
a、 dump（）；
a、 移位（“cw”）；
a、 dump（）；
var b=新矩阵（4，4[
1 ,2 ,3 ,4 ,
5 ,6 ,7 ,8 ,
9 ,10,11,12,
13,14,15,16
]);
b、 dump（）；
b、 班次（“ccw”）；
b、 dump（）公共类移位数组{
静态空移位数组（int[][]a，int索引，int n）{
如果（（n%2==0）和&（索引>=n/2））
返回；
如果（（n%2！=0）和&（索引>n/2））
返回；
int tempRowTopLast=a[index][n-1-index]；
int tempColRightLast=a[n-1-index][n-1-index]；
int tempRowBottomLast=a[n-1-index][index]；
int tempColLeftLast=a[index][index]；
内部温度，温度2；
temp=tempColLeftLast；
对于（int k=index+1；k=index；k--）{
temp2=a[n-1-指数][k]；
a[n-1-指数][k]=温度；
temp=temp2；
}
temp=tempRowBottomLast；
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class RotateMatrix {

    public static void main(String args[] ) throws Exception {
        Scanner s = new Scanner(System.in);

        int d = s.nextInt();

        int[][] matrix = new int[d][d];
        for(int i = 0; i < d; i++) {
            for(int j = 0; j < d; j++) {
                matrix[i][j] = Integer.parseInt(s.next());
            }
        }

        matrix = rotate(matrix);

        for(int i = 0; i < matrix.length; i++) {
            for(int j = 0; j < matrix.length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }

        s.close();
    }

    public static int[][] rotate(int[][] matrix) {
        if(matrix == null || matrix.length == 0 || matrix.length == 1) {
            return matrix;
        }

        List<Integer> outerCircle = getOuterCircle(matrix);
        matrix = removeOuterCircle(matrix);
        //rotating outer circle
        outerCircle.add(0, outerCircle.remove(outerCircle.size() - 1));

        matrix = rotate(matrix);

        matrix = addOuterCircle(outerCircle, matrix);

        return matrix;

    }

    private static int[][] addOuterCircle(List<Integer> outerCircle, int[][] matrix) {

        int d = matrix.length + 2;
        int[][] newMatrix = new int[d][d];

        //Adding the outer circle to the matrix
        for(int j = 0; j < d; j++) {
            newMatrix[0][j] = outerCircle.remove(0);
        }
        for(int i = 1; i < d; i++) {
            newMatrix[i][d-1] = outerCircle.remove(0);
        }
        for(int j = d-2; j >= 0; j--) {
            newMatrix[d-1][j] = outerCircle.remove(0);
        }
        for(int i = d-2; i >= 1; i--) {
            newMatrix[i][0] = outerCircle.remove(0);
        }

        //Adding the inner matrix
        for(int i = 0; i < matrix.length; i++) {
            for(int j = 0; j < matrix[i].length; j++) {
                newMatrix[i + 1][j + 1] = matrix[i][j];
            }
        }

        return newMatrix;

    }

    private static List<Integer> getOuterCircle(int[][] matrix) {
        int d = matrix.length;

        List<Integer> outerCircle = new ArrayList<Integer>();

        for(int j = 0; j < d; j++) {
            outerCircle.add(matrix[0][j]);
        }
        for(int i = 1; i < d; i++) {
            outerCircle.add(matrix[i][d-1]);
        }
        for(int j = d-2; j >= 0; j--) {
            outerCircle.add(matrix[d-1][j]);
        }
        for(int i = d-2; i >= 1; i--) {
            outerCircle.add(matrix[i][0]);
        }

        return outerCircle;
    }

    private static int[][] removeOuterCircle(int[][] matrix) {      
        int d = matrix.length;
        int[][] newMatrix = new int[d-2][d-2];

        for(int i = 1; i < d-1; i++) {
            for(int j = 1; j < d-1; j++) {
                newMatrix[i-1][j-1] = matrix[i][j];
            }
        }

        return newMatrix;
    }

}

import java.util.Scanner;

public class RotateMatrix
{
    static int rows = 0;
    static int cols = 0;

    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        Scanner scan = new Scanner(System.in);
        rows = scan.nextInt();
        cols = scan.nextInt();
        int rots = scan.nextInt();
        int[][] matrix = new int[rows][cols];
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                matrix[i][j] = scan.nextInt();
            }
        }
        for (int i = 0; i < rots; i++)
            rotate(matrix, 0, rows - 1, 0, cols - 1);

        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
        scan.close();
    }

    public static int[][] rotate(int[][] arr, int rowStart, int rowEnd, int colStart, int colEnd)
    {

        if (rowStart == rowEnd && colStart == colEnd)
        {
            return arr;
        }
        if (rowStart > rowEnd || colStart > colEnd)
        {
            return arr;
        }

        int temp = arr[rowStart][colStart];
        for (int j = colStart; j < colEnd; j++)
        {
            arr[colStart][j] = arr[colStart][j + 1];
        }
        for (int i = rowStart; i < rowEnd; i++)
        {
            arr[i][colEnd] = arr[i + 1][colEnd];
        }
        for (int i = colEnd; i > colStart; i--)
        {
            arr[rowEnd][i] = arr[rowEnd][i - 1];
        }
        for (int i = rowEnd; i > rowStart; i--)
        {
            arr[i][colStart] = arr[i - 1][colStart];
        }

        if (rows == 1)
        {
            arr[colEnd][rowStart] = temp;
        }
        else
            arr[rowStart + 1][colStart] = temp;

        System.out.println("-----------------------------------------\n");
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("-----------------------------------------\n");
        rotate(arr, rowStart + 1, rowEnd - 1, colStart + 1, colEnd - 1);
        return arr;
    }
}

# @param A : list of list of integers
# @return the same list modified
def rotate(A):
    for row in range(len(A) // 2):
        for col in range(row, len(A)-1 - row): # First col already takes care of last.
            r = row
            c = col
            tmp1 = A[r][c]
            while True:
                next_r = c
                next_c = len(A) - 1 - r
                tmp2 = A[next_r][next_c]
                A[next_r][next_c] = tmp1
                if next_r == row and next_c == col:
                    break
                tmp1 = tmp2
                r = next_r
                c = next_c
    return A