递归导致的分段错误

Question

我正在编写一个程序，该程序将取一个 1-10 之间的数字并显示所有可能的数字排列方式。

前 输入：3 输出：

   1 2 3
   1 3 2
   2 1 3
   2 3 1
   3 1 2
   3 2 1

每当我输入 9 或 10 时，程序都会给出分段错误并转储内核。我相信问题是我的递归算法被调用了太多次。有人可以帮助指出我如何限制必要的递归调用量吗？这是我当前的代码：

void rearange(int numbers[11], int index, int num, int fact) {

  int temp = numbers[index];
  numbers[index] = numbers[index-1];
  numbers[index-1] = temp;

  int i;
  for (i = 1; i <= num; ++i) // print the current sequence
  {
    printf("%d ", numbers[i]);
  }
  printf("\n");

  fact--;  // decrement how many sequences remain
  index--; // decrement our index in the array

  if (index == 1) // if we're at the beginning of the array
    index = num;    // reset index to end of the array

  if (fact > 0) // If we have more sequences remaining
    rearange(numbers, index, num, fact);    // Do it all again! :D
}

int main() {
  int num, i; // our number and a counter

  printf("Enter a number less than 10: ");
  scanf("%d", &num); // get the number from the user

  int numbers[11]; // create an array of appropriate size
  // fill array
  for (i = 1; i <= num; i++) { // fill the array from 1 to num
    numbers[i] = i;
  }

  int fact = 1; // calculate the factorial to determine
  for (i = 1; i <= num; ++i) // how many possible sequences
  {
    fact = fact * i;
  }

  rearange(numbers, num, num, fact); // begin rearranging by recursion

  return 0;
}

Answer 1

当您进行尽可能多的递归调用时，

9! (362880) 和 10! (3628800) 是会溢出 call stack 的巨大数字。因为必须存储所有局部变量和形式参数。您要么必须增加堆栈大小，要么将递归转换为迭代。

在 linux 上，你可以这样做：

ulimit -s unlimited

将堆栈大小设置为无限制。默认值通常为 8MB。

Answer 2

计算排列可以迭代地完成，但即使你递归地做，也不需要有一个巨大的堆栈（比如建议增加你的系统堆栈的答案）。事实上，你只需要很少的筹码量。考虑一下：

0 1      <- this needs **2** stackframes 
1 0                and an for-loop of size 2 in each stackframe

0 1 2    <- this needs **3** stackframes 
0 2 1              and an for-loop of size 3 in each stackframe
1 0 2
1 2 0
2 1 0
2 0 1

置换 9 个元素需要 9 个堆栈帧，并在每个堆栈帧中通过 9 个元素进行 for 循环。

编辑：我冒昧地为您的重新排列功能添加了一个递归计数器，它现在打印如下：

Enter a number less than 10: 4
depth 1      1 2 4 3
depth 2      1 4 2 3
depth 3      4 1 2 3
depth 4      4 1 3 2
depth 5      4 3 1 2
depth 6      3 4 1 2
depth 7      3 4 2 1
depth 8      3 2 4 1
depth 9      2 3 4 1
depth 10      2 3 1 4
depth 11      2 1 3 4
depth 12      1 2 3 4
depth 13      1 2 4 3
depth 14      1 4 2 3
depth 15      4 1 2 3
depth 16      4 1 3 2  which is obviously wrong even if you do it recursively.
depth 17      4 3 1 2
depth 18      3 4 1 2
depth 19      3 4 2 1
depth 20      3 2 4 1
depth 21      2 3 4 1
depth 22      2 3 1 4
depth 23      2 1 3 4
depth 24      1 2 3 4
....

递归叶应该是唯一输出的叶，因此深度应该是恒定的并且很小（等于您输入的数字）。

编辑 2：

好的，写代码了。试试看：

#include "stdio.h"
void betterRecursion(int depth, int elems, int* temp) {
    if(depth==elems) {
        int j=0;for(;j<elems;++j){
            printf("%i ", temp[j]);
        }
        printf("   (at recursion depth %u)\n", depth);
    } else {
        int i=0;for(;i<elems;++i){
            temp[depth] = i;
            betterRecursion(depth+1, elems, temp);
        }
    }
}
int main() {
    int temp[100];
    betterRecursion(0, 11, temp); // arrange the 11 elements 0...10
    return 0;
}

Answer 3

我会让您的 rearange 函数迭代 - 添加 do while，并删除递归调用：

void rearange(int numbers[11], int index, int num, int fact) {
    int temp;
    do
    {
      temp = numbers[index];
      numbers[index] = numbers[index-1];
      numbers[index-1] = temp;

      int i;
      for (i = 1; i <= num; ++i) // print the current sequence
      {
        printf("%d ", numbers[i]);
      }
      printf("\n");

      fact--;  // decrement how many sequences remain
      index--; // decrement our index in the array

      if (index == 1) // if we're at the beginning of the array
        index = num;    // reset index to end of the array

    } while (fact > 0);
}

Answer 4

这不是深度递归的任务。 尝试发明一些对堆栈更友好的算法。 以下代码在速度方面比堆栈大小更麻烦...... 它有点慢，例如对于 n=1000，但它有效。

#include <stdio.h>

void print_arrangement(int n, int* x)
{
  int i;
  for(i = 0; i < n; i++)
  {
  printf("%s%d", i ? " " : "", x[i]);
  }
  printf("\n");
}

void generate_arrangements(int n, int k, int* x)
{
    int i;
    int j;
    int found;

    if (n == k)
    {
        print_arrangement(n, x);
    }
    else
    {
    for(i = 1; i <= n; i++)
    {
        found = 0;
        for(j = 0; j < k; j++)
        {
            if (x[j] == i)
            {
                found = 1;
            }
        }
        if (!found)
        {
            x[k] = i;
            generate_arrangements(n, k + 1, x);
        }
    }   
    }
}

int main(int argc, char **argv)
{
  int x[50];
  generate_arrangements(50, 0, x);
}

Answer 5

您的程序不必要地使用了太多递归。它使用n! 递归，而实际上n 就足够了。

要仅使用 n 递归，请考虑递归函数的以下逻辑：

• 它接收一个数组nums[] 的n 要排列的唯一编号
• 排列中可以有 n 不同的第一个数字，因为数组中有 n 不同的数字
• （关键步骤）循环遍历nums[] 的元素，并在每次迭代中创建一个新数组，但删除当前元素，并递归到相同的函数，将这个较短的数组作为参数传递
• 随着递归的深入，参数数组会越来越小
• 当只剩下一个元素时，递归结束

使用此算法，您的递归不会比n 更深，并且不会出现分段错误。关键在于关键步骤，您可以在其中构建一个新的数字数组，该数组始终比输入数组短 1 项。

附带说明，请确保在提交之前检查程序的输出，例如通过| sort | uniq | wc -l 运行它以确保您获得正确数量的组合，并检查没有与@ 重复的内容987654333@（如果没有重复，则输出应为空）。

剧透警告：这是我在C++ 中使用上述算法的变体的实现： https://gist.github.com/janosgyerik/5063197