我的螺旋矩阵算法中的错误在哪里？矩阵的大小=输入N ^ 2

Question

所以我用C＃创建一个螺旋矩阵。

螺旋阵列是前N ^ 2个自然数的正方形排列，当数字向内旋转时，数字会逐渐增加。

例如：

我应该使用算法做到这一点，但我的最终结果如下：

我的代码如下：

    private static void FillMatrix (int[ , ] matrix, int n)
    {
        int positionX = 0;
        int positionY = 0;

        int direction = 0; // The initial direction is "right"
        int stepsCount = n - 1; // stepsCount decrements after 3/2/2/2/2...
        int stepPosition = 0; // 0 steps already performed
        int counter = 1; // counter increments after every turn

        for (int i = 1; i < n * n; i++)
        {
            matrix[positionY, positionX] = i;

            //moving logic:

            if (stepPosition < stepsCount)
            {
                stepPosition++;
            }
            else
            {
                counter++;
                stepPosition = 1;

                if (counter <= 3)
                {
                    direction = (direction + 1) % 4;
                }

                else if (counter % 2 != 0 && counter >= 5 || counter == 4)
                {
                    stepsCount = stepsCount - 1;
                    direction = (direction + 1) % 4;
                }
            }


            // Move to the next cell in the current direction
            switch (direction)
            {
                case 0:
                    // right
                    positionX++;
                    break;
                case 1:
                    // down
                    positionY++;
                    break;
                case 2:
                    // left
                    positionX--;
                    break;
                case 3:
                    // up
                    positionY--;
                    break;
            }
        }
    }

    private static void PrintMatrix (int[ , ] matrix, int n)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                Console.Write("{0,3}", matrix[i, j]);
            }
            Console.WriteLine();
        }
    }

    static void Main(string[] args)
    {
        int n;

        Console.WriteLine("Please enter N: ");
        bool checkN = int.TryParse(Console.ReadLine(), out n);

        if (checkN)
        {
            int[,] spiralMatrix = new int[n,n];

            FillMatrix(spiralMatrix, n);

            PrintMatrix(spiralMatrix, n);
        }

        Console.ReadKey();
    }
}

}

非常感谢任何帮助！

Answer 1

你决定何时转弯以及采取多少步骤的逻辑有一个错误，而且它比必要的更复杂。决定何时转弯的更好方法是检查矩阵本身。使用-1预填充矩阵，然后在左上角开始填充矩阵。当你看到-1时，继续直行;如果您到达矩阵的一端，或者下一个位置中有-1，则转弯。这会使您的stepPosition和stepCount变量变得不必要，并且会缩短您的代码。

另一个有用的技巧是向右转：不是将方向保持为单个变量，而是保持两个＆＃34; delta＆＃34;变量 - dx和dy

if (positionX < 0 || positionX == n || positionY < 0 || positionY == N || matrix[positionX][positionY] != -1) {
    int temp = dy;
    dy = dx;
    dx = -temp;
}
positionX += dx;
positionY += dy;

Answer 2

我已经解决了这个问题。

我的算法存在问题。当从外部填充矩阵时，顺序线的大小的数字模式是N，N-1，N-1，N-2，N-2，N-3，N-3 ...等等

例如，在N大小为4的螺旋矩阵中，模式如下：

4对。 3下来。 还剩3个。 2起来。 2对。 1下来。 1左。

我原本以为这个模式开始了：

3对。 3下来。 3离开。

我忘了再包含一个移动元素，导致算法无法正确填充。

一旦我将条件语句更改为以下代码，它就允许正确的输出。为了澄清我应该从数组的0元素中的1开始。为混乱道歉。

以下代码：

            int positionX = 0;
            int positionY = 0;

            int direction = 0; // The initial direction is "right"
            int stepsCount = n - 1; // stepsCount decrements after 1/2/2/2/2... turns
            int stepPosition = 1; // 1 steps already performed
            int counter = 0; // counter increments after every change in direction

            for (int i = 1; i < n * n + 1; i++)
            {
                matrix[positionY, positionX] = i;

                //moving logic:

                if (stepPosition <= stepsCount)
                {
                    stepPosition++;
                }
                else
                {
                    counter++;
                    stepPosition = 1;

                    if (counter % 2 != 0)
                    {
                        stepsCount = stepsCount - 1;
                        direction = (direction + 1) % 4;
                    }
                    else if (counter % 2 == 0)
                    {
                        direction = (direction + 1) % 4;
                    }

                }

结果是比基于该规则检查零和转弯更简单的方法，因为它是绝对可以吸收的。

以下示例结果：