Question

我正在编写一个递归函数来查找数字的强大功能，它似乎正在编译但不会输出任何内容。

#include <iostream>

using namespace std;

int stepem(int n, int k);

int main()
{
    int x, y;

    cin >> x >> y;

    cout << stepem(x, y) << endl;

    return 0;
}

int stepem(int n, int k)
{
    if (n == 0)
        return 1;
    else if (n == 1)
        return 1;
    else
        return n * stepem(n, k-1);
}

我试过调试它，它说问题出在这一行： return n * stepem(n, k-1);

k似乎得到了一些奇怪的价值，但我无法弄清楚为什么？

Answer 1

你应该检查指数k，而不是从不改变的数字本身。

int rPow(int n, int k) {
    if (k <= 0) return 1;
    return n * rPow(n, --k);
}

你的k得到了奇怪的值，因为你会继续计算直到你的内存耗尽为止，你会创建许多堆栈帧，其中k变为“-infinity”（假设）。

也就是说，理论上编译器可以在这个特定的场景中给你一个永远不会终止的警告。但是，通常不可能一般地解决这个问题（查看暂停问题）。

Answer 2

你的算法错了：

int stepem(int n, int k)
{
    if (k == 0) // should be k, not n!
        return 1;
    else if (k == 1) // this condition is wrong
        return 1;
    else
        return n * stepem(n, k-1);
}

如果你用stepem(2, 3)（例如）调用它，你将得到2 * 2 * 1而不是2 * 2 * 2 * 1.你不需要else-if条件：

int stepem(int n, unsigned int k) // unless you want to deal with floating point numbers, make your power unsigned
{
    if (k == 0)
        return 1;
    return n * stepem(n, k-1);
}

Answer 3

没有测试过，但我想它应该给你你想要的东西，它是尾递归的。

int stepemi(int result, int i int k) {
    if (k == 0 && result == i)
        return 1;
    else if (k == 0)
        return result;
    else
        return stepem(result * i, i, k-1);
}

int stepem(int n, int k) {
   return stepemi(n, n, k);
}

这段代码和另一个例子的最大区别在于我的版本可以针对尾递归调用进行优化。这意味着当你递归地调用stepemi时，它不需要在内存中保留任何内容。如您所见，它可以替换当前堆栈框架中的变量，而无需创建新的变量。没有变量可以保留在内存中以计算下一个递归。

如果您可以进行优化的尾递归调用，则还意味着该函数将使用固定数量的内存。它永远不会超过3个整数。

另一方面，您首先编写的代码会创建一个堆栈框架等待返回的树。每个递归将累加到下一个递归。

Answer 4

好吧，只是根据我的评论发布答案（似乎我错过了添加评论而不是回复:-D）。我认为，主要是您有两个错误：您正在检查n而不是k，并且当权力为1时您返回1，而不是返回n。我认为stepem函数看起来应该是这样的：

编辑：更新以支持@ZacHowland建议的负指数

float stepem(int n, int k)
{
    if (k == 0)
        return 1;
    else
        return (k<0) ?((float) 1/n) * stepem(n, k+1)  :n * stepem(n, k-1);
}

Answer 5

// Power.cpp : Defines the entry point for the console application.
//


#include <stream>

using namespace std;

int power(int n, int k);

void main()
{
    int x,y;

    cin >>x>>y;

    cout<<power(x,y)<<endl;


}

int power(int n, int k)
{
    if (k==0)
        return 1;
    else if(k==1) // This condition is working :) //
        return n;
    else
        return n*power(n,k-1);
}

Answer 6

您的程序错误且不支持用户给出的负值，检查一下

int power(int n, int k){
'if(k==0)
 return 1;
 else if(k<0)
 return ((x*power(x,y+1))*(-1));
 else
 return n*power(n,k-1);
 }

Answer 7

抱歉，我改变了你的变量名但我希望你能理解;

#include <iostream>
using namespace std;

double  power(double , int);// it should be double because you also need to handle negative powers which may cause fractions

int main()
{
 cout<<"please enter the number to be powered up\n";
 double number;
 cin>>number;
 cout<<"please enter the number to be powered up\n";
 int pow;
 cin>>pow;
 double result = power(number, pow);
 cout<<"answer is "<<result <<endl;
}

 double power( double x, int n)
{

if (n==0)
    return 1;
if (n>=1)
    /*this will work OK even when n==1 no need to put additional condition as n==1
    according to calculation it will show x as previous condition will force it to be x;
    try to make pseudo code on your note book you will understand what i really mean*/
    if (n<0)
    return x*power(x, n-1);
   return 1/x*power(x, n+1);// this will handle negative power as you should know how negative powers are handled in maths
}

Answer 8

int stepem(int n, int k)

{
    if (k == 0)   //not n cause you have to vary y i.e k if you want to find x^y
        return 1; 
    else if (k == 1)
        return n;  //x^1=x,so when k=1 it should be x i.e n
    else
        return n * stepem(n, k-1);
}

递归函数查找数字的幂

8 个答案: