Algorithm 二维阵列圆旋转算法？

给定NxN二维数组。编写一个函数，使其顺时针旋转1个元素（几乎旋转）

变成：

[5][1][2][3]
[9][0][6][4]
[3][1][7][8]
[4][5][6][2]

更新：

---

这是一个在线采访问题——HackerRank。我无法解决它。到目前为止，我在StackOverflow中发现的所有问题都是90度旋转（如果您在某处发现此问题，请在评论中共享链接）。

我不太确定您遇到了什么样的问题，因为显而易见的解决方案效果很好：

原始阵列：

final int[]a={{1,2,3,4}，{5,6,7,8}，{9,0,1,2}，{3,4,5,6}；

轮换：

for（int i=0；i<（a.length>>1）；i++）{
最终int minx=i；
最终int miny=i；
最终整数maxx=a.length-1-i；
最终整数maxy=a.length-1-i；
int incx=1，incy=0；
int prev=a[miny][minx]；
对于（intx=（minx+1），y=miny；（（x！=minx）| |（y！=miny））；x+=incx，y+=incy）{
最终内部温度=a[y][x]；
a[y][x]=上一次；
prev=温度；
如果（（x==maxx）&&（incx==1））{
incx=0；
incy=1；
}
如果（（y==maxy）和&（incy==1））{
incx=-1；
incy=0；
}
如果（（x==minx）&（incx==1））{
incx=0；
incy=-1；
}
}
a[miny][minx]=prev；
}

输出：

5 1 2 3 
9 0 6 4 
3 1 7 8 
4 5 6 2 

---

Java中的另一个解决方案

行和列距离是声明的，而不是计算的

final int[]a={{1,2,3,4}，{5,6,7,8}，{9,0,1,2}，
{ 3, 4, 5, 6 } };
final int[]dRow={{1,0,0,0}，{1,1,0，-1}，
{ 1, 0, -1, -1 }, { 0, 0, 0, -1 } };
final int[][]dCol={{0，-1，-1}，{0,0，-1,0}，
{ 0, 1, 0, 0 }, { 1, 1, 1, 0 } };
int[]tmp={{0,0,0,0}，{0,0,0,0}，{0,0,0,0}，
{ 0, 0, 0, 0 } };
//将a旋转到tmp
for（int row=0；row

我很快就尝试了一下，在Python中对square-matrix使用了稍微不同的方法（您指定了NxN）。对于每个层，我展开、旋转并重新应用。这肯定比必要的工作要多，但是很容易跟踪，并且感觉符合逻辑-并且适用于+n步旋转

def rotate_matrix(m, n):
    assert len(m) is len(m[0]), 'Assertion: rotation requires square matrix'

    rotated_matrix = [[None] * len(m[0]) for _ in range(len(m))]

    def _rotate_layer(ns):
        return ns[n:] + ns[:n]

    def _nth_layer(l):
        left = [m[i][l-1] for i in range(l-1, len(m)-(l-1))] 
        bottom = m[len(m)-1-(l-1)][l:len(m)-(l-1)]  
        right = [m[i][len(m[0])-l] for i in reversed(range(l-1, len(m)-l))] 
        upper = m[l-1][len(m[0])-l-1:l-1:-1]
        return left + bottom + right + upper

    def _apply_layer(l):
        ns = _rotate_layer(_nth_layer(l))
        for i in range(l-1, len(m)-(l-1)):
            rotated_matrix[i][l-1] = ns.pop(0)
        for i in range(l, len(m)-(l-1)):
            rotated_matrix[len(m)-1-(l-1)][i] = ns.pop(0)
        for i in reversed(range(l-1, len(m)-l)):
            rotated_matrix[i][len(m[0])-l] = ns.pop(0)
        for i in reversed(range(l, len(m[0])-l)):
            rotated_matrix[l-1][i] = ns.pop(0)

    for i in range(1, len(m)/2+1):
        _apply_layer(i)

    return rotated_matrix

---

你试过什么？在速度、优雅度、存储等方面是否有任何特殊要求/限制？无任何要求。正如我所写的，我没有通过这个面试问题，希望看到/学习不同的实现。

def rotate_matrix(m, n):
    assert len(m) is len(m[0]), 'Assertion: rotation requires square matrix'

    rotated_matrix = [[None] * len(m[0]) for _ in range(len(m))]

    def _rotate_layer(ns):
        return ns[n:] + ns[:n]

    def _nth_layer(l):
        left = [m[i][l-1] for i in range(l-1, len(m)-(l-1))] 
        bottom = m[len(m)-1-(l-1)][l:len(m)-(l-1)]  
        right = [m[i][len(m[0])-l] for i in reversed(range(l-1, len(m)-l))] 
        upper = m[l-1][len(m[0])-l-1:l-1:-1]
        return left + bottom + right + upper

    def _apply_layer(l):
        ns = _rotate_layer(_nth_layer(l))
        for i in range(l-1, len(m)-(l-1)):
            rotated_matrix[i][l-1] = ns.pop(0)
        for i in range(l, len(m)-(l-1)):
            rotated_matrix[len(m)-1-(l-1)][i] = ns.pop(0)
        for i in reversed(range(l-1, len(m)-l)):
            rotated_matrix[i][len(m[0])-l] = ns.pop(0)
        for i in reversed(range(l, len(m[0])-l)):
            rotated_matrix[l-1][i] = ns.pop(0)

    for i in range(1, len(m)/2+1):
        _apply_layer(i)

    return rotated_matrix