Question

目前在递归函数上进行赋值。有人被要求做一个斐波纳契计划并且做了很多问题。但是我需要为它制作一个计数器，这就是我被卡住的地方。

我有这个功能

int fibonacci(int n)
{
    if( n == 0 )
    {
        //my fibonacci code 
    }
    else if( n == 1 )
    {
        //my fibonacci code
    }
    else 
    { 
        //my fibonacci code
    }
}

那我该如何添加一个计数器？有时我添加一个计数器，它会返回错误的数字。

编辑为了澄清，我的函数可以很好地生成Fibonacci数。我只想在函数内部添加一个计数器，这样我就可以看到每次希望它生成Fibonacci数时都会被调用多少次。

我已经尝试过以下方法之一，我在main函数中初始化一个计数器，然后在递归中递增它，但不知道数字是否正确。例如，如果我的斐波纳契数是610，我说这个函数是609次，这是正确的吗？

Answer 1

我猜你只需要计算用于演示目的，对吧？通过引用传入计数器变量并在每次调用开始时增加一次，可以很容易地实现对调用的计数，如下所示：

#include <iostream>

// ...

int fibonacci(int n, int &count)
{
    ++count;
    // other code ...

    // and every time you call fibonacci recursively,
    // simply pass in the same reference, like so:
    if (...) {
        fibonacci (new_n, count);
    }
}

int main(int argc, char** argv)
{
    // call it with an int variable initialized to 0:
    int fibCnt = 0;
    fibonacci(10, fibCnt);
    std::cout << "Function was called "<<fibCnt<<" times"<<std::endl;
}

Answer 2

您不需要任何计数器。你的代码已经差不多了

int fibonacci(int n)
{
    if( n == 0 )
    {
        return f_0
    }
    else if( n == 1 )
    {
        return f_1
    }
    else 
    { 
        return f_n using recursion
    }
}

由于Fibonacci数是通过递归定义的，最后一种情况很明显。另外两个只需要关闭递归关系，即避免最后一种情况导致无限循环。

Answer 3

首先完成代码。我给你递归方程式：

fib(0) = *deleted*
fib(1) = *deleted*
fib(n) = *deleted*

您的计数器（您仍应在问题中指定）通常可以通过在函数外定义但在函数内更改的全局变量来实现。

参考问题的编辑：

你的号码不好。为了不再破坏你的任务，我在Erlang中给你答案，所以你仍然需要做一些工作来弄清楚如何在你的C ++任务中做到正确。： - ）

-module(fib).

-export([f/1]).

%% returns a tupel { fibonacci value, number function calls }
f(0) -> {0, 1};
f(1) -> {1, 1};
f(X) -> 
    {F1, C1} = f(X - 1),  %% decompose tuple
    {F2, C2} = f(X - 2),
    {F1 + F2, C1 + C2}.  %% return value

从shell运行它会产生：

Eshell V5.10.1  (abort with ^G)
1> c("q:/doc/erlang/fib", [{outdir, "q:/doc/erlang/"}]).
{ok,fib}
2> fib:f(0).
{0,1}
3> fib:f(1).
{1,1}
4> fib:f(2).
{1,2}
5> fib:f(3).
{2,3}
6> fib:f(4).
{3,5}
7> fib:f(5).
{5,8}
8> fib:f(6).
{8,13}
9> fib:f(7).
{13,21}
10> fib:f(15).
{610,987}
11>

因此，我得到987函数调用以获得F（15）= 610的值。

这里有趣的是，在评论中我们讨论了Fibonacci递归F的正确启动条件（情况类似于微分方程，不同的起点使您获得不同的轨迹/解决方案）。

我错了F（0）= 1和F（1）= 1，而@WhozCraig正确地指出它应该是F（0）= 0和F（1）= 1。

如果你看一下上面的Erlang代码，你会发现产生函数调用次数的系列的计算也是一个Fibonacci类型（添加系列的最后两个成员），但是那个是一个起始值为1和1！ :-)

Answer 4

使用struct可能就是答案。

struct factorial
{
  factorial() : counter(0)
  {}

  uint64_t foo(uint64_t x) {
    ++counter;

    if(x < 2)
      return 1;
    else
      return x * foo(x - 1);
  }

  template <class T>
  T operator()(const T& x) {
    return foo(x);
  }

  uint64_t counter;
} factorial;

在这种情况下，foo是阶乘函数。但是没有那个名字，因为结构的用法是。

// output and calls
struct factorial foo;
std::cout << foo(5) << "\n";
std::cout << foo.counter << "\n";

// output
std::cout << factorial(5) << "\n";

C ++函数内的递归计数器

4 个答案: