6

我有一维的 int 数组：

var intArray=new[] { 1, 2, 3, 4, 5, 6 };

我想将其转换为二维，例如：

var intArray2D=new[,] { {1, 2}, {3, 4}, {5, 6} };

如何使用 C# 实现这一目标？

4

8 回答 8

2

也许有一个循环：

for (int i = 0; i < oldArr.Length; i=i+2)
{
    newArr[i/2, 0] = oldArr[i];
    newArr[i/2, 1] = oldArr[i + 1];
}

未经测试，但应该让你指出正确的方向......

于 2013-04-24T22:26:22.843 回答
2

如果一维数组包含原始数据的行主要顺序，并且二维数组的总容量等于一维数组的长度，则可以使用它。

int[] source = new int[6];
int[,] target = new int[3, 2];
Buffer.BlockCopy(source, 0, target, 0, source.Length * sizeof(int));

请注意，与Array.Copy其他数组/列表方法不同，Buffer.BlockCopy它对多个字节的数据进行操作，即使数组的每个元素都大于 1 个字节。它也只对原始数据类型的数组进行操作。

附加参考：

编辑：这是一个完整的单元测试。

[TestMethod]
public void SOTest16203210()
{
    int[] source = new int[6] { 1, 2, 3, 4, 5, 6 };
    int[,] destination = new int[3, 2];
    Buffer.BlockCopy(source, 0, destination, 0, source.Length * sizeof(int));
    Assert.AreEqual(destination[0, 0], 1);
    Assert.AreEqual(destination[0, 1], 2);
    Assert.AreEqual(destination[1, 0], 3);
    Assert.AreEqual(destination[1, 1], 4);
    Assert.AreEqual(destination[2, 0], 5);
    Assert.AreEqual(destination[2, 1], 6);
}
于 2013-04-25T01:20:56.830 回答
1

我相信您想将一个整数数组拆分为一个由两个整数组成的数组：

int[] list = new int[] { 1, 2, 3, 4, 5, 6};
int[][] newlist = new int[list.Length / 2][];
for (int i = 0, n = 0; i < list.Length; i += 2, n++)
{
    newlist[n] = new[] { list[i], list[i + 1] };
}

要将其Points特别分配给您，您可以尝试：

List<Point> plist = new List<Point>();
for (int i = 0; i < list.Length; i += 2)
{
    plist.Add(new Point(list[i], list[i + 1]));
}
于 2013-04-24T22:30:38.067 回答
1

您可以使用此代码。在这里你可以发送任何你喜欢的长度。您可以将 arry[] 转换为 arry[,] 任何 lenth.2 或 3 或任何您喜欢的！只要 size % a.length ==0 !!!!

代码

        static int[,] convert(int[] a, int size)
    {
        int[,] value = new int[a.Length / size, size];
        int counter = 0;
        //
        for (int b = 0; b < value.GetLength(0); b++)
            for (int c = 0; c < value.GetLength(1); c++)
            {
                 value[b, c] = a[counter];
                  counter++;
           }
        return value;
    }
于 2013-04-24T22:31:43.790 回答
0

你可以试试这个：

int [] a = {1,2,3,4,5,6};
int [,] b = new int[a.Length/2,2];

for(int i = 0;i<a.Length;i++)
{
    b[i/2,i%2] = a[i];
}

请注意，i/2 是整数除法，因此 4/2 和 5/2 都会给出 2，这是原始数组中元组 5 和 6 在 2Darray 中的正确索引。第二个索引是使用提醒除以 2 时确定的，如果索引为偶数，则为 0，如果原始数组中的项目的索引为奇数，则为 1。

于 2013-04-24T22:30:31.620 回答
0

我会考虑这个数组的任何维度：

public class TestClass {
    public static void TestMethod2D() {
        var intLinear=new[] { 1, 2, 3, 4, 5, 6 };
        var indexer2D=new ArrayIndexer<int>(3, 2);

        for(var i=intLinear.Length; i-->0; indexer2D[i]=intLinear[i])
            ;

        var int2D=(int[,])indexer2D.ToArray();
    }

    public static void TestMethod4D() {
        var intLinear=new[] { 1, 2, 3, 4, 5, 6 };
        var indexer4D=new ArrayIndexer<int>(2, 2, 2, 2);

        for(var i=intLinear.Length; i-->0; indexer4D[i]=intLinear[i])
            ;

        var int4D=(int[, , ,])indexer4D.ToArray();
    }
}

public partial class ArrayIndexer<T> {
    public Array ToArray() {
        return m_Array;
    }

    public ArrayIndexer(params int[] lengths) {
        m_Array=Array.CreateInstance(typeof(T), lengths);
    }

    public T this[params int[] indices] {
        set {
            m_Array.SetValue(value, indices.Transform(m_Array));
        }

        get {
            return (T)m_Array.GetValue(indices.Transform(m_Array));
        }
    }

    Array m_Array;
}

public static partial class ArrayExtensions {
    public static int[] Transform(
        this int[] indices, Array array, bool isRowMajor=true) {
        if(indices.Length>array.Rank)
            return indices;
        else {
            var list=indices.ToList();

            if(isRowMajor)
                list.Reverse();

            for(int r, q=0, i=0, count=array.Rank; count-->0; ++i) {
                var index=isRowMajor?count-i:i;

                if(indices.Length>i) {
                    q=Math.DivRem(indices[i]+q, array.GetLength(index), out r);
                    list[i]=r;
                }
                else {
                    if(index<0) {
                        list.Add(q);
                        q=0;
                    }
                    else {
                        q=Math.DivRem(q, array.GetLength(index), out r);
                        list.Add(r);
                    }
                }
            }

            if(isRowMajor)
                list.Reverse();

            return list.ToArray();
        }
    }
}

ArrayExtensions.Transform是一个索引转换器，它使用给定数组的几何形状执行线性转换。isRowMajor控制布局，例如您认为的int[,]inx, y或 in y, xorder。

于 2013-04-25T00:43:19.780 回答
0

如果维度的乘积相同，最快的方法可能是使用固定语句固定矩阵，然后使用 Marshalling 类将连续块从数组复制到 IntPtr 从您获得的 void* 创建固定的。

您必须将其包装在 unsafe 语句中，并在程序集的构建配置中启用 unsafe。

于 2013-04-24T22:26:26.263 回答
0

我已将其从 vb 转换为 c#

int Size = OldArray.Length;
int[,] NewPoints = null;

if (Size % 2 != 0) {
  //Error - Array has odd number of elements!
} else {
  for (i = 0; i <= Size - 1; i += 2) {
    Array.Resize(ref AllPoints, (i / 2) + 1, 2);
    NewPoints[i / 2, 0] = OldArray(i);
    NewPoints[i / 2, 1] = OldArray(i + 1);
  }
}
于 2013-04-24T22:41:42.157 回答