Question

我使用递归算法列出数组元素p = {1,2,3}的所有可能排列。以下是我正在使用的简单递归实现：

void swap(int x, int y){
    int temp = array[x];
    array[x]=array[y];
    array[y]=temp;    
    return;
}

void printArray(int size){
    int i;

    for (i=0;i<size;i++)
        printf("%d ", array[i]);

    printf("\n");    
    return;
}

void permute(int k,int size){
    int i;

    if (k==0)
        printArray(size);
    else{
        for (i=k-1;i>=0;i--){
            swap(i,k-1);
            permute(k-1,size);
            swap(i,k-1);
        }
    }    
    return;
}

问题是不是打印它们我想将每个排列添加到2D数组。目前，我正在将排列打印到文件，然后将其读取到2D数组，但我认为应该有更好的方法来实现这一点。

Answer 1

使用动态数组。值得庆幸的是，您事先了解了阵列的总大小：

size_t const n = 3;             //  array size, e.g. [ 0, 1, 2 ]

size_t const nf = factorial(n); //  number of permutations

int * array = malloc(nf * n * sizeof *array);  // space for a flat array of n*nf
size_t  cur = 0;                               // current row

void add_row(int * src)
{
    for (size_t i = 0; i != n; ++i)
    {
        array[cur * n + i] = src[i];
    }
    ++cur;
}

您必须完全add_row次致电nf。在您的计划结束时，请说free(array);。

数组的k ^th行包含array[k * n]元素，最多array[k * n + n]，零基础和半开公约。

Answer 2

将这些声明为全球：

int **resultArray;
resultArray = malloc( (n!) * sizeof(int *));    // n! : factorial of n
for(i=0; i<(n!); i++)
    resultArray[i] = malloc(size * sizeof(int));
int index = 0;

这填写二维数组：

void addToArray(int size){
    int i;
    for(i=0 ; i<size ; i++)
        resultArray[index][i] = array[i];
    index++;
}

Answer 3

我不确定我是否理解这个问题。只需创建一个数组或列表，并直接从您的函数中引用它。就像你从任何其他函数访问数组或列表一样。

或者，您可以将数组或列表作为参数传递，并在每次递归调用该函数时传递该参数。

Answer 4

由于您可以提前知道有多少个排列（n!表示长度为n的数组），您可以预先创建此数组，然后将其传递给递归函数。递归函数可以给出一个参数，告诉它它正在生成n'th置换，以便在写入包含所有排列的数组时它知道正确的索引。所以算法是这样的（伪代码提前）：

void doPermute( array, arrayLen, n, permutations ) {
  if ( n < fact(arrayLen) ) {
    /* At this point, generate permutation of array and write it to
     * permutations[n].
     */

    /* Recurse, generating next permutation. */
    doPermute( array, arrayLen, n + 1, permute );
  }
}

int **permute( array, arrayLen ) {
  /* Allocate an array big enough to hold `arrayLen!` versions of the input
   * array.
   */
  int **permutations = malloc( fact( arrayLen ) * (sizeof(int) * arrayLen) );

  /* Invoke recursion */
  doPermute( array, arrayLen, 0, permutations );
}

如何在递归算法中将结果添加到数组？

4 个答案: