二维阵列到一维阵列C#

我有两种算法可以将随机2d数组（mön或möm）转换为一维数组。我想知道是否有一种方法可以让它们以相反的方向工作，并将结果转换为1d数组，保存数字顺序。下面是我的程序的完整代码和一张图片，看看我的两个算法是如何工作的。 代码：

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用系统诊断；
使用静态系统。数学；
名称空间MyProgram
{
公共课程
{
公共静态void Main（字符串[]args）
{
Console.Write（“输入行数：”）；
int n=int.Parse（Console.ReadLine（））；
Console.Write（“输入列数：”）；
int m=int.Parse（Console.ReadLine（））；
int[]arr1=新的int[n*m]；
int[，]arr2=新的int[n，m]；
智力选择；
做
{
Console.WriteLine（“选择选项：”）；
Console.WriteLine（“\t1:对角线”）；
控制台写入线（“\t2:Spiral”）；
Console.WriteLine（“\t3:Exit”）；
控制台。写（“您的选择：”）；
choice=int.Parse（Console.ReadLine（））；
开关（选择）
{
案例1：
{
SetArray（arr2）；
打印阵列（arr2）；
对角线（arr2，arr1）；
打印阵列（arr1）；
打破
}
案例2：
{
SetArray（arr2）；
打印阵列（arr2）；
螺旋线（arr2，arr1）；
打印阵列（arr1）；
打破
}
}
Console.WriteLine（）；
Console.WriteLine（）；
}while（选项！=5）；
}
静态空对角线（int[，]array2，int[]array1）
{
int k=0；
int行=0；
int col=0；
while（k0&&length>0）
{
对于（int j=CorrectY；j0&&lengthX>0）长--；
否则就断了；
对于（int j=longer-1；j>=CorrectY&&Count0&&lengthX>0）lengthX--；
否则就断了；
对于（int i=lengthX-1；i>=CorrectX&&Count

这似乎对我的后向

对角线

：

static void BackwardDiagonal(int[,] array2, int[] array1) {

    int k = 0;
    int row = 0;
    int col = 0;
    while (k < array1.Length) {
        array2[row, col] = array1[k];  // just swap sides of the assignment...
        if ((row + col) % 2 == 0) {
            if ((row == 0) && (col != array2.GetLength(1) - 1)) { col++; } else {
                if (col == array2.GetLength(1) - 1) { row++; } else { row--; col++; }
            }
        } else {
            if ((col == 0) && (row != array2.GetLength(0) - 1)) { row++; } else {
                if (row == array2.GetLength(0) - 1) { col++; } else { row++; col--; }
            }
        }
        k += 1;
    }
}

private static void BackwardSpiral(int[,] array2, int[] array1)
{
    int lengthX = array2.GetLength(0);
    int lengthY = array2.GetLength(1);
    int Product = lengthX * lengthY;
    int CorrectY = 0;
    int CorrectX = 0;
    int Count = 0;
    while (lengthX > 0 && lengthY > 0)
    {
        for (int j = CorrectY; j < lengthY && Count < Product; j++)
        {
            array2[CorrectX, j] = array1[Count];  // just swap sides of the assignment...
            Count++ ;
        }
        CorrectX++;
        for (int i = CorrectX; i < lengthX && Count < Product; i++)
        {
            array2[i, lengthY - 1] = array1[Count];
            Count++ ;
        }
        if (lengthY > 0 && lengthX > 0) lengthY-- ;
        else break;
        for (int j = lengthY - 1; j >= CorrectY && Count < Product; j--)
        {
            array2[lengthX - 1, j] = array1[Count];
            Count++ ;
        }
        if (lengthY > 0 && lengthX > 0) lengthX-- ;
        else break;
        for (int i = lengthX - 1; i >= CorrectX && Count < Product; i--)
        {
            array2[i, CorrectY] = array1[Count];
            Count++ ;
        }

        CorrectY++;
    }
}

我还将其添加到switch语句中以实现它：

case 4: 
    {
        SetArray(arr2);
        PrintArray(arr2);
        Diagonal(arr2, arr1);
        PrintArray(arr1);
        int[,] arr3 = new int[n, m];  // new blank array to fill with arr1
        BackwardDiagonal(arr3, arr1);  // fill arr3 from backward Diagonal algorithm
        PrintArray(arr3);
        break;
    }
case 5: 
    {
        SetArray(arr2);
        PrintArray(arr2);
        Spiral(arr2, arr1);
        PrintArray(arr1);
        int[,] arr3 = new int[n, m];  // new blank array to fill with arr1
        BackwardSpiral(arr3, arr1);  // fill arr3 from backward Spiral algorithm
        PrintArray(arr3);
        break;
    }

在进行此操作时，还要确保有

}While（选项！=3）do

循环结束时执行code>，以便退出程序

实际上你是什么人

case 4: 
    {
        SetArray(arr2);
        PrintArray(arr2);
        Diagonal(arr2, arr1);
        PrintArray(arr1);
        int[,] arr3 = new int[n, m];  // new blank array to fill with arr1
        BackwardDiagonal(arr3, arr1);  // fill arr3 from backward Diagonal algorithm
        PrintArray(arr3);
        break;
    }
case 5: 
    {
        SetArray(arr2);
        PrintArray(arr2);
        Spiral(arr2, arr1);
        PrintArray(arr1);
        int[,] arr3 = new int[n, m];  // new blank array to fill with arr1
        BackwardSpiral(arr3, arr1);  // fill arr3 from backward Spiral algorithm
        PrintArray(arr3);
        break;
    }

delegate void Apply(int row, int col, int index);

static void Diagonal(int rows, int cols, Apply action)
{
    int k = 0;
    int row = 0;
    int col = 0;
    int length = rows * cols;
    while (k < length)
    {
        action(row, col, k);
        if ((row + col) % 2 == 0)
        {
            if ((row == 0) && (col != cols - 1)) { col++; }
            else
            {
                if (col == cols - 1) { row++; }
                else { row--; col++; }
            }
        }
        else
        {
            if ((col == 0) && (row != rows - 1)) { row++; }
            else
            {
                if (row == rows - 1) { col++; }
                else { row++; col--; }
            }
        }
        k += 1;
    }
}

SetArray(arr2);
PrintArray(arr2);
Diagonal(n, m, (r, c, i) => arr1[i] = arr2[r, c]);
PrintArray(arr1);
// Inverse
var arr3 = new int[n, m];
Diagonal(n, m, (r, c, i) => arr3[r, c] = arr1[i]);
PrintArray(arr3);