在 C++ 中编写递归函数的最佳方法？

发布于 2024-09-06 07:56:29 字数 461 浏览 2 评论 0原文

问题
我想知道这是否是实现可变深度递归的可行方法，以便我可以在每一步运行一个函数以及描述问题的任何更好/其他解决方案。
描述
假设我希望有一个函数可以以模式填充数组
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
    }
}

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

原文

Question
I wish to know if this is a viable way to implement variable depth recursion so that I can run a function at each step and any better/other solutions to the description problem.
Description
Suppose I wish to have a function that fills an array either in pattern
x,y,x,y,x,ywhere x and y are variables defined by some algorithm
and x,y,z,x,y,z where x, y and z are variables defined by the same algorithm.

This should continue for all number of variables. Is this a viable way to implement it.

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

EDIT: Removed the incorrect return type previously referred to. Brainfart.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

绻影浮沉 2024-09-13 07:56:29

因此，根据您的评论，您想知道设置递归函数的最佳方法。你所做的将会起作用，但是它是令人费解的并且有点令人困惑。我会做的简化是：

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

    --n;
    recurse_n(n);

    // Your algorithm stuff here.
}

这将使您更容易看到正在发生的事情。我要补充的一件事是，您可能想在调用 recurse_n 之前执行算法操作，但这一切都取决于您的算法正在做什么。

如果您考虑一下，按照我编写的方式，在执行任何算法工作之前，它将递归直到 n 小于或等于 0。您可能想要执行算法工作然后递归。

So, based on your comment you want to know the best way to set up a recursive function. What you have done will work, but it is convoluted and slightly confusing. What I would do to simplify it is:

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

    --n;
    recurse_n(n);

    // Your algorithm stuff here.
}

That will make it easier to see what is going on. One thing I would add though is that you might want to do the algorithm stuff before the call to recurse_n, but that all depends on what your algorithm is doing.

If you think about it, the way I have written it, it will recurse until n is less than or equal to 0 before doing any of the algorithm work. It might be that you want to do the algorithm work then recurse.

回复收藏 0 原文

还如梦归 2024-09-13 07:56:29

首先，使用 std::vector 和循环（我假设 x()、y() 和 z() 返回您需要的 int，您也可以在那里使用向量存储值）：

void fill( std::vector<int> &vec, std::vector<int> &values )
{
    size_t nValues = values.size();
    size_t sz = vec.size();
    for( size_t i=0; i<sz; i=i+nValues )
    {
        for( size_t j=0; j<nValues; ++j )
        {
            vec[i] = values[j];
        }
    }
}

int main()
{
    std::vector<int> vec;
    std::vector<int> values;
    /* fill values vector here */
    vec.resize( 512 ); // (arbitraty) size you need
    fill( vec, values );

    return 0;
}

这更像 C++，并且比递归函数快得多。另外：存储 x、y 和 z 值，以便相应的算法仅执行一次。

First of all, use a std::vector and a loop (I'm assuming x(), y() and z() return the ints you need, you could also use a vector there to store the values):

void fill( std::vector<int> &vec, std::vector<int> &values )
{
    size_t nValues = values.size();
    size_t sz = vec.size();
    for( size_t i=0; i<sz; i=i+nValues )
    {
        for( size_t j=0; j<nValues; ++j )
        {
            vec[i] = values[j];
        }
    }
}

int main()
{
    std::vector<int> vec;
    std::vector<int> values;
    /* fill values vector here */
    vec.resize( 512 ); // (arbitraty) size you need
    fill( vec, values );

    return 0;
}

This is more C++-ish and much faster than a recursive function. Also: store x, y, and z values so that the corresponding algorithm only executes once.

回复收藏 0 原文

零度℉ 2024-09-13 07:56:29

我认为这不是一种可行的方法，因为：让 T(n) 表示函数的运行时间（取决于输入参数 n）。

基本情况n=0 产生以下运行时间：T(0)=c，即某个恒定的运行时间c。

现在您可以为运行时间定义一个递归公式，其中 n>0：T(n)=sum(i = 0 to n-1: T(i)) 。

如果你解这个方程，你会得到T(n)=O(2^n)，这意味着你的算法是指数的，这意味着它在实践中不易处理。

回复收藏 0 原文

末蓝 2024-09-13 07:56:29

我对这个问题有点不清楚，但听起来你有一组变量 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));
}

I'm a little unclear on the question, but it sounds like you have a set of variables a, b, c, ..., z and you want to fill an array so it contains a, b, c, ..., z, a, b, c, ..., z, a, .... If so, it's probably simplest to put the source variables in their own one-pass array a, b, c, ..., z and memcpy it to the destination array until it's filled

#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));
}

回复收藏 0 原文