c# - 旋转外部 N x N 方阵，同时保持内部方阵不变

Question

如何旋转(或移动)二维方形数组，但不移动任何不在数组“边界”上的元素？

例子:

1  2  3  4
12 13 14 5
11 15 16 6
10  9  8 7

我想要的:

12  1  2 3
11 13 14 4
10 15 16 5
 9  8  7 6

那只是一个例子。我需要这个来处理 N 宽度的任何方阵，其中 2 < N < 100

Answer 1

如果数组存储为 2 阶正方形 .NET 数组，则代码非常简单，主要由四个循环组成 - 每条边一个:

var array = new [,] {
  {  1,  2,  3,  4,  5 },
  { 16, 17, 18, 19,  6 },
  { 15, 24, 25, 20,  7 },
  { 14, 23, 22, 21,  8 },
  { 13, 12, 11, 10,  9 }
};

// Rank = 2 and "square" and side length >= 2 checks removed for clarity.
var sideLength = array.GetLength(0);
// Save first element from top edge.
var element00 = array[0, 0];
// Rotate left edge.
for (var y = 1; y < sideLength; y += 1)
  array[y - 1, 0] = array[y, 0];
// Rotate bottom edge.
for (var x = 1; x < sideLength; x += 1)
  array[sideLength - 1, x - 1] = array[sideLength - 1, x];
// Rotate right edge.
for (var y = sideLength - 2; y >= 0; y -= 1)
  array[y + 1, sideLength - 1] = array[y, sideLength - 1];
// Rotate top edge.
for (var x = sideLength - 2; x > 0; x -= 1)
  array[0, x + 1] = array[0, x];
// Put saved element in place.
array[0, 1] = element00;

现在原始数组已经按照问题中的描述进行了旋转。

如果数组存储为一维数组，则更容易创建一个类来执行旋转。此类可以存储可跨方法调用使用的属性(数组和边长)以简化代码。

这四个循环包含相同的逻辑，尽管它们看起来不同:

class ArrayRotator<T> {

  public ArrayRotator(T[] array) {
    if (array == null)
      throw new ArgumentNullException("array");
    var sideLength = (Int32) Math.Sqrt(array.Length);
    if (sideLength*sideLength != array.Length)
      throw new ArgumentException("Not a square.", "array");
    Array = array;
    SideLength = sideLength;
  }

  public T[] Array { get; private set; }

  public Int32 SideLength { get; private set; }

  public void RotateArray() {
    if (SideLength < 3)
      return;
    // Save first element from top edge.
    var element00 = Array[0];
    // Rotate left edge.
    for (var y = 1; y < SideLength; y += 1)
      CopyElement(0, y, 0, y - 1);
    // Rotate bottom edge.
    for (var x = 1; x < SideLength; x += 1)
      CopyElement(x, SideLength - 1, x - 1, SideLength - 1);
    // Rotate right edge.
    for (var y = SideLength - 2; y >= 0; y -= 1)
      CopyElement(SideLength - 1, y, SideLength - 1, y + 1);
    // Rotate top edge.
    for (var x = SideLength - 2; x > 0; x -= 1)
      CopyElement(x, 0, x + 1, 0);
    // Put saved element in place.
    Array[1] = element00;
  }

  void CopyElement(Int32 x1, Int32 y1, Int32 x2, Int32 y2) {
    Array[GetIndex(x2, y2)] = Array[GetIndex(x1, y1)];
  }

  Int32 GetIndex(Int32 x, Int32 y) {
    return y*SideLength + x;
  }

}

下面是如何使用这个类:

var array = new [] {
   1,  2,  3,  4,
  12, 13, 14,  5,
  11, 15, 16,  6,
  10,  9,  8,  7
};
var arrayRotator = new ArrayRotator<Int32>(array);
arrayRotator.RotateArray();

现在原始数组已经按照问题中的描述进行了旋转。