0

我在这个递归问题上遇到了困难。我以为我有一个答案，但它不起作用，我根本不知道为什么，所以我想我会问专家。请放轻松，我在 15 多年前学习 C 编程，即便如此，我也可能是 B 学生。我不知道 C++ 或 Java。

目的是生成从 0 到 (n[j]-1) 的所有可能的整数组合，其中 j 可以是任意整数。现在它被硬编码为 2，但我希望它最终能够取任何值。

无论如何，这是我的代码。在此先感谢您的帮助。

编辑：对于下面的代码，我定义了 2 个序列，第 0 个序列的长度为 2 (0,1)，第一个序列的长度为 3 (0, 1, 2)。所需的输出如下：

p[0][0] = 0
p[0][1] = 0
p[1][0] = 0
p[1][1] = 1
p[2][0] = 0
p[2][1] = 2
p[3][0] = 1
p[3][1] = 0
p[4][0] = 1
p[4][1] = 1
p[5][0] = 1
p[5][1] = 2

那是，

  • 第 0 个组合贡献了序列 0 的 0 和序列 1 的 0
  • 第一个组合贡献了序列 0 的 0 和序列 1 的 1
  • 第二个组合贡献了序列 0 中的 0 和序列 1 中的 2
  • 第 3 个组合从序列 0 中贡献 1，从序列 1 中贡献 0
  • 第 4 个组合贡献了序列 0 中的 1 和序列 1 中的 1
  • 第 5 个组合贡献序列 0 的 1 和序列 1 的 2

我希望这能让我更清楚我想要做什么！

#include <stdio.h>
#include <stdlib.h>

int recurse (int **p, int *n, int nclass, int classcount, int combcount);

int recurse (int **p, int *n, int nclass, int classcount, int combcount)
{
  int k, j, kmax;
  kmax = n[classcount];
  j = classcount;

  if (j == nclass)  {
    return (combcount+1);
  }

  for (k = 0; k < kmax; k++)  {
    p[combcount][j] = k;
    combcount = recurse (p, n, nclass, j+1, combcount);
  }
}

int main (void)
{
  int **p, n[2], i, j;

  n[0] = 2;
  n[1] = 3;

  p = (int **) malloc ((n[0]*n[1]) * sizeof (int *));
  for (i = 0; i < (n[0]*n[1]); i++)  {
    p[i] = (int *) malloc (2 * sizeof (int));
    for (j = 0; j < 2; j++)
      p[i][j] = -1;
  }

/* p[i][j] = the value of the integer in the ith combination
   arising from the sequence 0...n[j]-1 */

  recurse (p, n, 2, 0, 0);

  for (i = 0; i < (n[0]*n[1]); i++)
    for (j = 0; j < 2; j++)
      printf ("%d %d: %d\n", i, j, p[i][j]);

  for (i = 0; i < (n[0]*n[1]); i++)
    free (p[i]);
  free (p);
  return (0);
}
4

2 回答 2

0 
#include <stdio.h>
#include <stdlib.h>

void recurse(int *n, int *accum, int **p, int N, int k) {
    static int comb;
    int i, j;
    if (k == 0)
        comb = 0;
    if (k == N) {
        for (i = 0; i < N; ++i)
            p[comb][i] = accum[i];
        comb++;
    }
    else
        for (i = 0; i < n[k]; ++i) {
            accum[k] = i;
            recurse(n, accum, p, N, k+1);
        }
}

int main(void) {
    const int N = 2;
    int n[N];
    int accum[N];
    int **p;
    int mult;
    int i, j;
    n[0] = 2;
    n[1] = 3;
    for (mult = 1, i = 0; i < N; mult *= n[i], ++i);
    p = malloc(mult*sizeof(int*));
    for (i = 0; i < mult; i++)
        p[i] = malloc(N*sizeof(int));
    recurse(n, accum, p, N, 0);
    for (i = 0; i < mult; ++i)
        for (j = 0; j < N; ++j)
            printf("p[%d][%d] = %d\n", i, j, p[i][j]);
    for (i = 0; i < mult; i++)
        free(p[i]);
    free(p);
}
于 2012-05-25T07:35:54.743 回答
0 
#include <stdio.h>
#include <stdlib.h>

int recurse (int **p, int *n, int nclass, int classcount, int p_size){
    int i, j, jmax, k, kmax;

    if (classcount == nclass) return 1;

    i = 0;
    kmax = n[classcount];
    while(i < p_size){
        for (k = 0; k < kmax; ++k){
            jmax = recurse (p, n, nclass, classcount+1, p_size);
            for(j = 0;j < jmax; ++j)
                p[i++][classcount] = k;
        }
    }
    return kmax*jmax;
}

int main (void){
    int **p, n[2], i, j;
    int sizeAll, sizeN;

    n[0] = 2;
    n[1] = 3;
    sizeAll = n[0]*n[1];
    sizeN = sizeof(n)/sizeof(int);
    p = (int **) malloc (sizeAll * sizeof (int *));
    for (i = 0; i < sizeAll; ++i) {
        p[i] = (int *) malloc (sizeN * sizeof (int));
        for (j = 0; j < sizeN; ++j)
            p[i][j] = -1;
    }

    recurse (p, n, sizeN, 0, sizeAll);

    for (i = 0; i < sizeAll; ++i)
        for (j = 0; j < sizeN; ++j)
            printf ("%d %d: %d\n", i, j, p[i][j]);

    for (i = 0; i < sizeAll; ++i)
        free (p[i]);
    free (p);
    return (0);
}
于 2012-05-25T12:30:01.387 回答