如何在C#中调整多维(2D)数组的大小？


How to resize multidimensional (2D) array in C#?

我尝试了以下操作，但它只返回一个错误的数组。

1
2
3
4
5
6
    T[,] ResizeArray< T >(T[,] original, int rows, int cols)
    {
        var newArray = new T[rows,cols];
        Array.Copy(original, newArray, original.Length);
        return newArray;
    }

数组类中的大多数方法仅适用于一维数组，因此您必须手动执行复制：

1
2
3
4
5
6
7
8
9
10
T[,] ResizeArray< T >(T[,] original, int rows, int cols)
{
    var newArray = new T[rows,cols];
    int minRows = Math.Min(rows, original.GetLength(0));
    int minCols = Math.Min(cols, original.GetLength(1));
    for(int i = 0; i < minRows; i++)
        for(int j = 0; j < minCols; j++)
           newArray[i, j] = original[i, j];
    return newArray;
}

要了解为什么它不适用于Array.Copy，您需要考虑内存中多维数组的布局。数组项并没有真正存储为二维数组，而是逐行连续存储。所以这个数组：

1
2
{ { 1, 2, 3 },
  { 4, 5, 6 } }

实际上是这样安排在内存中的：{ 1, 2, 3, 4, 5, 6 }

现在，假设您要再添加一行和一列，以使数组如下所示：

1
2
3
{ { 1, 2, 3, 0 },
  { 4, 5, 6, 0 },
  { 0, 0, 0, 0 } }

现在在内存中的布局如下：{ 1, 2, 3, 0, 4, 5, 6, 0, 0, 0, 0, 0 }

但是Array.Copy将所有数组视为一维。 MSDN说：

When copying between multidimensional arrays, the array behaves like a long one-dimensional array, where the rows (or columns) are conceptually laid end to end

因此，当您尝试将原始数组复制到新数组时，它只是将一个内存位置复制到另一个，从而以一维表示形式给出：

{ 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0 }。

如果将其转换为二维表示，则会得到以下内容：

1
2
3
{ { 1, 2, 3, 4 },
  { 5, 6, 0, 0 },
  { 0, 0, 0, 0 } }

这就是为什么要弄乱数组的原因...请注意，如果您更改行数而不是列数，则它将起作用。

相关讨论

这结合了Thomas和Manuel的答案，并提供了Array.Copy的性能优势以及增加和减小数组大小的能力。

1
2
3
4
5
6
7
8
9
10
11
    protected T[,] ResizeArray< T >(T[,] original, int x, int y)
    {
        T[,] newArray = new T[x, y];
        int minX = Math.Min(original.GetLength(0), newArray.GetLength(0));
        int minY = Math.Min(original.GetLength(1), newArray.GetLength(1));

        for (int i = 0; i < minY; ++i)
            Array.Copy(original, i * original.GetLength(0), newArray, i * newArray.GetLength(0), minX);

        return newArray;
    }

请注意，数组的x和y轴取决于您自己的实现，您可能需要在0和1之间切换以实现所需的效果。

谢谢托马斯，您的解释非常有帮助，但是您实施的解决方案太慢了。我对其进行了修改，以充分利用Array.Copy。

1
2
3
4
5
6
7
8
9
10
    void ResizeArray< T >(ref T[,] original, int newCoNum, int newRoNum)
    {
        var newArray = new T[newCoNum,newRoNum];
        int columnCount = original.GetLength(1);
        int columnCount2 = newRoNum;
        int columns = original.GetUpperBound(0);
        for (int co = 0; co <= columns; co++)
            Array.Copy(original, co * columnCount, newArray, co * columnCount2, columnCount);
        original = newArray;
    }

这里，我假设行多于列，因此我将数组构造为[列，行]。这样一来，我就可以在整个列上使用Array.Copy(一次快于一个单元格)。

它只能用于增加数组的大小，但也可以对其进行调整以减小大小。

对于多维数组的一般大小调整：

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
26
27
28
29
30
31
32
33
34
public static class ArrayExtentions {
    public static Array ResizeArray(this Array arr, int[] newSizes) {
        if (newSizes.Length != arr.Rank) {
            throw new ArgumentException("arr must have the same number of dimensions as there are elements in newSizes","newSizes");
        }

        var temp = Array.CreateInstance(arr.GetType().GetElementType(), newSizes);
        var sizesToCopy = new int[newSizes.Length];
        for (var i = 0; i < sizesToCopy.Length; i++) {
            sizesToCopy[i] = Math.Min(newSizes[i], arr.GetLength(i));
        }

        var currentPositions = new int[sizesToCopy.Length];
        CopyArray(arr, temp, sizesToCopy, currentPositions, 0);

        return temp;
    }

    private static void CopyArray(Array arr, Array temp, int[] sizesToCopy, int[] currentPositions, int dimmension) {
        if (arr.Rank - 1 == dimmension) {
            //Copy this Array
            for (var i = 0; i < sizesToCopy[dimmension]; i++) {
                currentPositions[dimmension] = i;
                temp.SetValue(arr.GetValue(currentPositions), currentPositions);
            }
        } else {
            //Recursion one dimmension higher
            for (var i = 0; i < sizesToCopy[dimmension]; i++) {
                currentPositions[dimmension] = i;
                CopyArray(arr, temp, sizesToCopy, currentPositions, dimmension + 1);
            }
        }
    }
}

这基于Manuel的回答，还允许对复制的数据应用偏移量(例如，将源数组复制到目标数组的中心，而不是复制到[0，0])：

1
2
3
4
5
6
7
8
9
10
11
public static T[,] ResizeArray< T >(T[,] original, int newWidth, int newHeight, int offsetX = 0, int offsetY = 0)
{
    T[,] newArray = new T[newWidth, newHeight];
    int width = original.GetLength(0);
    int height = original.GetLength(1);
    for (int x = 0; x < width; x++) {
        Array.Copy(original, x * height, newArray, (x + offsetX) * newHeight + offsetY, height);
    }

    return newArray;
}

我一直在寻找类似的东西，但是这种东西可以有效地让我从两端"垫"一个2D数组，并且还具有缩小它的能力。

我已经进行了一个非常简单的测试：
数组是string [1000,1000]，我的机器平均每次调整大小为44ms。
调整大小每次将所有边上的填充增加或减少1，因此将复制数组中的所有数据。对于我的要求，此性能命中率超出了可接受范围。

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
26
27
28
29
30
public static void ResizeArray< T >(
    ref T[,] array, int padLeft, int padRight, int padTop, int padBottom)
{
    int ow = array.GetLength(0);
    int oh = array.GetLength(1);
    int nw = ow + padLeft + padRight;
    int nh = oh + padTop + padBottom;

    int x0 = padLeft;
    int y0 = padTop;
    int x1 = x0 + ow - 1;
    int y1 = y0 + oh - 1;
    int u0 = -x0;
    int v0 = -y0;

    if (x0 < 0) x0 = 0;
    if (y0 < 0) y0 = 0;
    if (x1 >= nw) x1 = nw - 1;
    if (y1 >= nh) y1 = nh - 1;

    T[,] nArr = new T[nw, nh];
    for (int y = y0; y <= y1; y++)
    {
        for (int x = x0; x <= x1; x++)
        {
            nArr[x, y] = array[u0 + x, v0 + y];
        }
    }
    array = nArr;
}

padLeft，padRight，padTop，padBottom可以为负或正。如果您输入全0，则生成的数组将与源数组相同。

这对于想要"滚动"其数组周围的元素的人特别有用。

希望对某人有用！