2

如果 A、B 和 C 都是内存中的类，并且数组是元素 0-2：

[0] = A
[1] = B
[2] = C

我想移动数组，使它变成这样：

[0] = C
[1] = A
[2] = B

我希望能够向任何一个方向前进，但我假设如果有人能指出我如何在一个方向上做到这一点，我可以找出另一个方向。

我想我应该提一下，如果可能的话，我需要这个而不需要迭代。

这是一个伪无限地形的 3D 游戏。数组中的每个对象都是地形数据块。我想改变它们，因为它们包含非常大的锯齿状数组，每个数组都有大量数据。当玩家移动时，我有地形滑动（进/出）内存。我从未考虑过仅执行 array.copy 来移动数组然后完全重建下一系列块的性能损失。

因此，为了消除这个相对较小的性能问题，我想用所描述的包装来移动数组，而不是通过重新分配内存来重建整个下一系列块，我将重新使用通过复制提到的巨大的锯齿状数组默认值，而不是完全重新初始化它们。

为了踢，你可以看到我之前在做什么：

public void ShiftChunks(strVector2 ChunkOffset) {
            while (ChunkOffset.X < 0) {
                Array.Copy(Chunks, 0, Chunks, 1, Chunks.Length - 1);

                for (int X = 1; X < maxChunkArraySize; X++)
                    for (int Z = 0; Z < maxChunkArraySize; Z++) 
                        Chunks[X][Z].SetArrayPosition(X, Z);

                Chunks[0] = new clsChunk[maxChunkArraySize];

                for (int Z = 0; Z < maxChunkArraySize; Z++) 
                    Chunks[0][Z] = new clsChunk(0, Z);

                ChunkOffset.X++;
            }

            while (ChunkOffset.X > 0) {
                Array.Copy(Chunks, 1, Chunks, 0, Chunks.Length - 1);

                for (int X = 0; X < maxChunkArraySize - 1; X++)
                    for (int Z = 0; Z < maxChunkArraySize; Z++) 
                        Chunks[X][Z].SetArrayPosition(X, Z);

                Chunks[maxChunkArraySize - 1] = new clsChunk[maxChunkArraySize];

                for (int Z = 0; Z < maxChunkArraySize; Z++) 
                    Chunks[maxChunkArraySize - 1][Z] = new clsChunk(maxChunkArraySize - 1, Z);

                ChunkOffset.X--;
            }

            while (ChunkOffset.Z < 0) {
                for (int X = 0; X < maxChunkArraySize; X++) {
                    Array.Copy(Chunks[X], 0, Chunks[X], 1, Chunks[X].Length - 1);
                    for (int Z = 1; Z < maxChunkArraySize; Z++) 
                        Chunks[X][Z].SetArrayPosition(X, Z);

                    Chunks[X][0] = new clsChunk(X, 0);
                }
                ChunkOffset.Z++;
            }

            while (ChunkOffset.Z > 0) {
                for (int X = 0; X < maxChunkArraySize; X++) {
                    Array.Copy(Chunks[X], 1, Chunks[X], 0, Chunks[X].Length - 1);

                    for (int k = 0; k < maxChunkArraySize - 1; k++) 
                        Chunks[X][k].SetArrayPosition(X, k);

                    Chunks[X][maxChunkArraySize - 1] = new clsChunk(X, maxChunkArraySize - 1);
                }
                ChunkOffset.Z--;
            }
        }

如果有人想就我如何做得更好或如何进一步优化代码发表意见，请随时告诉我。

4

3 回答 3

5 
static void Rotate<T>(T[] source)
{
  var temp = source[source.Length - 1];
  Array.Copy(source, 0, source, 1, source.Length - 1);
  source[0] = temp;
}
于 2013-10-30T22:28:30.617 回答
3

就在几天前，我恰好为此创建了确切的东西：

private static T[] WrapAround<T>(T[] arr, int amount) {
        var newArr = new T[arr.Length];

        while (amount > 1) {
            for (var i = 0; i < arr.Length; i++) {
                if (i != 0) {
                    newArr[i] = arr[i - 1];
                }

                if (i == 0) {
                    newArr[i] = arr[arr.Length - 1];
                }
            }

            arr = (T[]) newArr.Clone();
            amount--;
        }

        return newArr;
    }

编辑：实际上，@Matthias 的解决方案要容易得多。你可能想改用它。

于 2013-10-30T22:28:36.853 回答
1

这是一个函数，它将使用 just 沿任一方向（最多为数组的 +/- 长度）将数组旋转任意偏移量Array.Copy()。

这是马蒂亚斯上述回答的延伸。它分配一个具有偏移大小的临时数组来处理包装。

void Rotate<T>(T[] array, int offset) {
  if (offset==0) return;
  if (offset>0) {
    var temp = new T[offset];
    System.Array.Copy(array, array.Length-offset, temp, 0, offset);
    System.Array.Copy(array, 0, array, offset, array.Length-offset);
    System.Array.Copy(temp, 0, array, 0, offset);
  }else{
    var temp = new T[-offset];
    System.Array.Copy(array, 0, temp, 0, -offset);
    System.Array.Copy(array, -offset, array, 0, array.Length+offset);
    System.Array.Copy(temp, 0, array, array.Length+offset, -offset);
  }
}

但是，对于您描述的用例，根本不移动数组可能会更快，而是在检索数据时使用循环索引。

于 2016-11-28T06:28:24.497 回答