避免堆棧溢出（C中的迷宮生成器）

Question

我目前正在使用深度優先搜索算法在C中編寫迷宮生成器。 它工作得非常好，我對結果感到滿意，但是當我將迷宮的尺寸推得太遠（超過2000x2000）時，它會給我一個堆棧溢出。

我知道這是由於算法中使用的遞歸性，但我真的不知道如何避免這個問題......

以下是遞歸發生的程序示例：

* int dirs由隨機化的4個數字組成（1,2,3和4）

x和y是地圖中的坐標

void    recursive_gen(char **map, int x, int y, t_size size)
{
  int   *dirs;
  int   i;

  i = -1;
  dirs = gen_random_dirs();
  while (++i < 4)
    {
      if (dirs[i] == 1)
        up(map, x, y, size);
      if (dirs[i] == 2)
        right(map, x, y, size);
      if (dirs[i] == 3)
        down(map, x, y, size);
      if (dirs[i] == 4)
        left(map, x, y, size);
    }
}

並且有功能（另一個幾乎相同）：

void    up(char **map, int x, int y, t_size size)
{
  if (y - 2 < 0)
    return ;
  if (map[y - 2][x] == 'X')
    {
      map[y - 1][x] = '*';
      map[y - 2][x] = '*';
      recursive_gen(map, x, y - 2, size);
    }
}

編輯：所以我在迭代中做了同樣的事情，使用自定義堆棧來存儲coords。 它工作得很好，但我無法弄清楚10k * 10k迷宮是否無限循環，或者它真的很長（1000 * 1000需要43s，10k * 10k我在1000s停止了程序）

無論如何我可以優化嗎？ 這是新代碼：

void    recursive_gen(char **map, t_size size)
{
  int   *pos;
  int   *dirs;
  int   **stack;
  int   i;
  int   istack;

  istack = 0;
  pos = malloc(sizeof(int) * 2);
  pos[0] = 0;
  pos[1] = 0;
  stack = alloc_stack(size);
  while (is_stack_empty(stack) == 0)
    {
      dirs = gen_random_dirs();
      i = -1;
      while (++i < 4)
        {
          if (dirs[i] == 1 && up(map, pos, size, stack) == 1)
            break ;
          if (dirs[i] == 2 && right(map, pos, size, stack) == 1)
            break ;
          if (dirs[i] == 3 && down(map, pos, size, stack) == 1)
            break ;
          if (dirs[i] == 4 && left(map, pos, size, stack) == 1)
            break;
        }
      if (i == 4)
        {
          pos[0] = stack[istack][0];
          pos[1] = stack[istack][1];
          stack[istack][0] = -1;
          stack[istack][1] = -1;
          istack -= 1;
        }
      else
        istack += 1;
    }
}

新功能：

int     lastof_stack(int **stack)
{
  int   i;

  i = 0;
  while (stack[i][1] != -1)
    i++;
  return (i);
}

int     up(char **map, int *pos, t_size size, int **stack)
{
  if (pos[1] - 2 < 0)
    return (0);
  if (map[pos[1] - 2][pos[0]] == 'X')
    {
      map[pos[1] - 1][pos[0]] = '*';
      map[pos[1] - 2][pos[0]] = '*';
      pos[1] -= 2;
      stack[lastof_stack(stack)][0] = pos[0];
      stack[lastof_stack(stack)][1] = pos[1];
      return (1);
    }
  return (0);
}

編輯 ：使用自定義堆棧的工作迭代程序（完整工作）

這是最終代碼的示例！

int     sub_gen(int *pos, int **stack, int istack, int i)
{
  if (i == 4)
    {
      pos[0] = stack[istack][0];
      pos[1] = stack[istack][1];
      stack[istack][0] = -1;
      stack[istack][1] = -1;
      istack -= 1;
    }
  else
    istack += 1;
  return (istack);
}

void    recursive_gen(char **map, t_size size)
{
  int   *pos;
  int   *dirs;
  int   **stack;
  int   i;
  int   istack;

  istack = 0;
  pos = alloc_pos();
  stack = alloc_stack(size);
  while (stack[0][0] != -1)
    {
      dirs = gen_random_dirs();
      i = -1;
      while (++i < 4)
    if ((dirs[i] == 1 && up(map, pos, stack, istack) == 1) ||
            (dirs[i] == 2 && right(map, pos, size, stack, istack) == 1) ||
            (dirs[i] == 3 && down(map, pos, size, stack, istack) == 1) ||
            (dirs[i] == 4 && left(map, pos, stack, istack) == 1))
          break ;
      istack = sub_gen(pos, stack, istack, i);
    }
}

和功能

int     up(char **map, int *pos, int **stack, int i)
{
  if (pos[1] - 2 < 0)
    return (0);
  if (map[pos[1] - 2][pos[0]] == 'X')
    {
      map[pos[1] - 1][pos[0]] = '*';
      map[pos[1] - 2][pos[0]] = '*';
      pos[1] -= 2;
      stack[i + 1][0] = pos[0];
      stack[i + 1][1] = pos[1];
      return (1);
    }
  return (0);
}

如果有興趣的話，我可以在github上傳完整的代碼！

Answer 1

堆棧空間通常很小，並不足以容納所有遞歸調用的大量堆棧幀。 但另一方面，堆有很多空間（幾乎所有的虛擬地址空間）。

因此，您可以在其中創建一個自定義堆棧，其中只包含相關數據。

然后你使用while循環來處理堆棧上的每個實例。 您的代碼是DFS的一個版本。 查看如何在沒有遞歸的情況下執行DFS。

基本思想是從一個空堆棧開始並按下它上面的第一個坐標。

然后重復以下步驟，直到堆棧上有元素（使用while循環）。

1. 從堆棧中彈出一個元素
2. 執行該點的操作
3. 如果滿足條件，則將鄰居添加到堆棧中（類似於遞歸中使用的那些。提示：查看何時調用遞歸，您檢查的條件是什么）。
4. 如果堆棧不為空則重復。

如果你想避免所有代碼但又准備犧牲可移植性，還有另一種方法。

您可以在堆上分配一些空間（100個MB的順序），並通過將堆棧指針設置為那個來調用堆棧。 然后開始遞歸。 遞歸完成后切換回原始堆棧。

請記住，您可能必須更改線程環境塊的字段以更新堆棧限制和堆棧基礎，因為庫可能會檢查它們以檢查堆棧是否在限制內，或者是否已溢出。