避免堆栈溢出（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的顺序），并通过将堆栈指针设置为那个来调用堆栈。 然后开始递归。 递归完成后切换回原始堆栈。

请记住，您可能必须更改线程环境块的字段以更新堆栈限制和堆栈基础，因为库可能会检查它们以检查堆栈是否在限制内，或者是否已溢出。