C++ 用C+；编写递归函数的最佳方法+；？

问题
我想知道这是否是一种实现可变深度递归的可行方法，这样我就可以在每一步运行一个函数，以及描述问题的任何更好/其他解决方案。
说明
假设我希望有一个函数以模式填充数组

x，y，x，y，x，y

其中x和y是由某些算法定义的变量
和

x，y，z，x，y，z

其中x，y和z是由相同算法定义的变量

对于所有数量的变量，应继续执行此操作。这是一种可行的实施方式吗

void recurse_n(int n)
{
    while(n > 0)
    {
        --n;
        recurse_n(n);
        n = 0;
        // Use algorithm here
    }
}

---

编辑：删除了前面提到的不正确的返回类型。Brainfart。

我对这个问题有点不清楚，但听起来你有一组变量

a，b，c，…，z

，你想填充一个数组，使它包含

a，b，c，…，z，a，b，c，…，z，

。如果是这样的话，可能最简单的方法是将源变量放入它们自己的一次传递数组

a、b、c、…、z

和

memcpy

中，直到它被填充为止

#define NUM 3
int a, b, c; // source variables
void fill(int* arr, unsigned int size) {
    int src[] = {a, b, c};
    unsigned int i;
    for(i = 0; i < size / NUM; i++)
        memcpy(arr + (NUM * i), src, sizeof(int) * NUM);
    memcpy(arr + (NUM * i), src, sizeof(int) * (size % NUM));
}

#定义NUM 3
int a，b，c；//源变量
空白填充（整数*arr，无符号整数大小）{
int src[]={a，b，c}；
无符号整数i；
对于（i=0；i
我对这个问题有点不清楚，但听起来你有一组变量
a，b，c，…，z
，你想填充一个数组，使它包含
a，b，c，…，z，a，b，c，…，z，a，
。如果是这样的话，可能最简单的方法是将源变量放入它们自己的一次传递数组
a、b、c、…、z
和
memcpy
中，直到它被填充为止

#define NUM 3
int a, b, c; // source variables
void fill(int* arr, unsigned int size) {
    int src[] = {a, b, c};
    unsigned int i;
    for(i = 0; i < size / NUM; i++)
        memcpy(arr + (NUM * i), src, sizeof(int) * NUM);
    memcpy(arr + (NUM * i), src, sizeof(int) * (size % NUM));
}

#定义NUM 3
int a，b，c；//源变量
空白填充（整数*arr，无符号整数大小）{
int src[]={a，b，c}；
无符号整数i；
对于（i=0；i
我认为这不是一种可行的方法，因为：让
T（n）
表示函数的运行时间（取决于输入参数
n
）

基本情况
n=0
产生以下运行时间：
T（0）=c
，即一些常量运行时间
c

现在，您可以为运行时间定义一个递归公式，其中
n>0
：
T（n）=和（i=0到n-1:T（i））

如果你解这个方程，你会得到
T（n）=O（2^n）
，这意味着你的算法是指数的，这意味着它在实践中是不可处理的。
我认为这不是一个可行的方法，因为：让
T（n）
表示函数的运行时间（取决于输入参数
n
）

基本情况
n=0
产生以下运行时间：
T（0）=c
，即一些常量运行时间
c

现在，您可以为运行时间定义一个递归公式，其中
n>0
：
T（n）=和（i=0到n-1:T（i））

如果你解这个方程，你会得到
T（n）=O（2^n）
，这意味着你的算法是指数的，这意味着它在实践中是不可处理的。
因此，根据你的评论，你想知道建立递归函数的最佳方法。你所做的将会奏效，但它是复杂的，并且有点令人困惑。我要做的是简化它：

void recurse_n(int n) {
    if (n <= 0) {
        // Break-out condition
        return;
    }

    --n;
    recurse_n(n);

    // Your algorithm stuff here.
}

void递归（int n）{
如果（n是这样，根据您的评论，您想知道设置递归函数的最佳方法。您所做的工作将起作用，但它是复杂的，有点令人困惑。我要做的是简化它：

void recurse_n(int n) {
    if (n <= 0) {
        // Break-out condition
        return;
    }

    --n;
    recurse_n(n);

    // Your algorithm stuff here.
}

void递归（int n）{
如果（n首先，使用一个std:：vector和一个循环（我假设x（）、y（）和z（）返回您需要的
int
s，您也可以在那里使用一个vector来存储值）：

void fill（标准：：向量和向量，标准：：向量和值）
{
size_t nValues=values.size（）；
size_t sz=vec.size（）；
对于（size_t i=0；i首先，使用一个std:：vector和一个循环（我假设x（）、y（）和z（）返回所需的
int
s，您也可以在那里使用一个vector来存储值）：

void fill（标准：：向量和向量，标准：：向量和值）
{
size_t nValues=values.size（）；
size_t sz=vec.size（）；
对于（size_t i=0；iJimDaniel是对的，这里的递归是一种过度杀伤力。您没有从函数返回任何内容，看起来您只使用了“n”控制递归的数量。使用一个简单的for循环会更清晰、更高效。
JimDaniel是对的，这里的递归是一个过度的杀伤力。你没有从函数返回任何东西，看起来你只使用了“n”控制递归的数量。使用简单的for循环将更清晰、更高效。
如果您的算法满足以下要求，则递归填充数组是一个有效的（甚至是最好的）选项：

位置
n
处的值取决于其前面至少一些值的值
如果不先确定它所依赖的早期值，就无法（已知）确定位置
n
处的值
符合这些要求的一个例子是。因为如果不先确定所有之前的数字（尽管存在一些快捷方式），就无法确定第n个数字

不符合这些要求的一个例子是一个数组，该数组填充了索引的平方，其中位置
n
处的值正好是
n^2

最后，如果可能的话，我建议您根据DaveJohnston对您的问题的回答中的模式重写函数。
如果您的算法满足以下要求，则递归填充数组是一个有效的（甚至是最好的）选项：