Fatal编程技术网
  • cplusplus/
  • C++ 递归C++；函数计算：Bn（a）=Bn−；1(a)及7 ;；Bn−；2（a）式中B1（a）=B2（a）=a

C++ 递归C++；函数计算：Bn（a）=Bn−；1(a)及7 ;；Bn−；2（a）式中B1（a）=B2（a）=a

c++ function recursion

C++ 递归C++；函数计算：Bn（a）=Bn−；1(a)及7 ;；Bn−；2（a）式中B1（a）=B2（a）=a,c++,function,recursion,C++,Function,Recursion,我在计算这个特定程序的递归时遇到了一些困难。我尝试了一些不同的选择，但我对递归函数是全新的。程序中唯一允许我修改的部分是函数B的内部。 此函数计算：Bn（a）=Bn−1（a）×Bn−2（a），其中B1（a）=B2（a）=a。 所以B1（a）=a | B2（a）=a | B3（a）=a^2 | B4（a）=a^3 | B5（a）=a^5 |等等 #include <iostream> using namespace std; float B(float a, int n) { /

我在计算这个特定程序的递归时遇到了一些困难。我尝试了一些不同的选择，但我对递归函数是全新的。程序中唯一允许我修改的部分是函数B的内部。 此函数计算：Bn（a）=Bn−1（a）×Bn−2（a），其中B1（a）=B2（a）=a。 所以B1（a）=a | B2（a）=a | B3（a）=a^2 | B4（a）=a^3 | B5（a）=a^5 |等等

#include <iostream>
using namespace std;
float B(float a, int n)
{
   //Here is where I'm having an issue...
}
int main(void)
{ cout << "Input a float a, and an int n > 0: ";
   float a; int n;
   cin >> a >> n;
   cout << "B(" << a << ")_" << n << " = " << B(a,n) << endl;
   return 0;
}

#包括
使用名称空间std；
浮点数B（浮点数a，整数n）
{
//这是我遇到问题的地方。。。
}
内部主（空）
{cout>a>>n；

cout首先处理
n
为1或2的情况，这些情况被定义为返回
a
而不递归。这些是所谓的终止情况

然后对其他代码进行递归，每次从
n
中减去：


float B(float a, int n)
{
   if (n == 1 || n == 2) { return a; }

   return B(a, n - 1) * B(a, n - 2);
}


如果传入的
n
大于2，递归调用最终将到达终止情况，执行将在该点停止，并将最终结果返回到第一次调用

让我们以调用为例，
B（2，4）
。这与终止情况不匹配，因此函数将递归，如下所示：


    

  • B（2,4）
    将返回
    B（2,3）*B（2,2）
    • 

  • B（2,3）
    将返回
    B（2,1）*B（2,2）
    。我们将其替换为原始值，得到：
    （B（2,1）*B（2,2））*B（2,2）
    • 

  • 我们现在只剩下终止案例，所以我们可以用
    a
    ：
    （2*2）*2
    =23=8的值来替换这些案例
    • 


就实际发生的情况而言（不仅仅是代数简化），这将是调用树：


    

  • B（2，4）
    不是终止案例，它将调用：

      

    • B（2，3）
      不是终止案例，它将调用：

        

      • B（2，2）
        是一个终止案例，返回2
        • 

      • B（2，1）
        是一个终止案例，返回2
        • 

      • 返回值为2*2=4
        • 

      • 

    • B（2，2）
      是一个终止案例，返回2
      • 

    • 返回值为4*2=8
      • 

    • 

首先处理
n
为1或2的情况，这些情况被定义为返回
a
，而不递归。这些是所谓的终止情况

然后对其他代码进行递归，每次从
n
中减去：


float B(float a, int n)
{
   if (n == 1 || n == 2) { return a; }

   return B(a, n - 1) * B(a, n - 2);
}


如果传入的
n
大于2，递归调用最终将到达终止情况，执行将在该点停止，并将最终结果返回到第一次调用

让我们以调用为例，
B（2，4）
。这与终止情况不匹配，因此函数将递归，如下所示：


    

  • B（2,4）
    将返回
    B（2,3）*B（2,2）
    • 

  • B（2,3）
    将返回
    B（2,1）*B（2,2）
    。我们将其替换为原始值，得到：
    （B（2,1）*B（2,2））*B（2,2）
    • 

  • 我们现在只剩下终止案例，所以我们可以用
    a
    ：
    （2*2）*2
    =23=8的值来替换这些案例
    • 


就实际发生的情况而言（不仅仅是代数简化），这将是调用树：


    

  • B（2，4）
    不是终止案例，它将调用：

      

    • B（2，3）
      不是终止案例，它将调用：

        

      • B（2，2）
        是一个终止案例，返回2
        • 

      • B（2，1）
        是一个终止案例，返回2
        • 

      • 返回值为2*2=4
        • 

      • 

    • B（2，2）
      是一个终止案例，返回2
      • 

    • 返回值为4*2=8
      • 

    • 

首先处理
n
为1或2的情况，这些情况被定义为返回
a
，而不递归。这些是所谓的终止情况

然后对其他代码进行递归，每次从
n
中减去：


float B(float a, int n)
{
   if (n == 1 || n == 2) { return a; }

   return B(a, n - 1) * B(a, n - 2);
}


如果传入的
n
大于2，递归调用最终将到达终止情况，执行将在该点停止，并将最终结果返回到第一次调用

让我们以调用为例，
B（2，4）
。这与终止情况不匹配，因此函数将递归，如下所示：


    

  • B（2,4）
    将返回
    B（2,3）*B（2,2）
    • 

  • B（2,3）
    将返回
    B（2,1）*B（2,2）
    。我们将其替换为原始值，得到：
    （B（2,1）*B（2,2））*B（2,2）
    • 

  • 我们现在只剩下终止案例，所以我们可以用
    a
    ：
    （2*2）*2
    =23=8的值来替换这些案例
    • 


就实际发生的情况而言（不仅仅是代数简化），这将是调用树：


    

  • B（2，4）
    不是终止案例，它将调用：

      

    • B（2，3）
      不是终止案例，它将调用：

        

      • B（2，2）
        是一个终止案例，返回2
        • 

      • B（2，1）
        是一个终止案例，返回2
        • 

      • 返回值为2*2=4
        • 

      • 

    • B（2，2）
      是一个终止案例，返回2
      • 

    • 返回值为4*2=8
      • 

    • 

首先处理
n
为1或2的情况，这些情况被定义为返回
a
，而不递归。这些是所谓的终止情况

然后对其他代码进行递归，每次从
n
中减去：


float B(float a, int n)
{
   if (n == 1 || n == 2) { return a; }

   return B(a, n - 1) * B(a, n - 2);
}


如果传入的
n
大于2，递归调用最终将到达终止情况，执行将在该点停止，并将最终结果返回到第一次调用

让我们以调用为例，
B（2，4）
。这与终止情况不匹配，因此函数将递归，如下所示：