Question

我尝试过：

static public void power(int n, int X) {

        System.out.print( + " ");

        if (n>0) {
            power(n-1, X);
        }
    }

这不会产生值，因为我不确定该怎么做。

Answer 1

尝试一下

public int calculatePower(int base, int powerRaised)
{
    if (powerRaised != 0)
        return (base*calculatePower(base, powerRaised-1));
    else
        return 1;
}

Answer 2

static int power(int x, int y) 
{ 
    // Initialize result 
    int temp; 
    if( y == 0) // Base condition
        return 1; 
    temp = power(x, y/2); // recursive calling
    if (y%2 == 0) //checking whether y is even or not
        return temp*temp; 
    else
        return x*temp*temp;  
}

还有其他人编写了解决方案，可以给您正确的答案，但是它们的时间复杂度为O（n），因为您仅将功率降低1。下面的解决方案将花费较少的时间O（log n）。诀窍是

x^y = x^(y/2) * x^(y/2)

所以我们只需要计算x ^（y / 2），然后将其平方即可。现在，如果y为偶数，则没有问题，但是当y为奇数时，我们必须将其乘以x。例如

3 ^ 5 = 3 ^（5/2）* 3 ^（5/2）但是（5/2）= 2，因此上述方程将变为3 ^ 2 * 3 ^ 2，因此我们必须再次将其乘以3，然后它将变为3 * 3 ^（5/2）* 3 ^（5/2 ）那么3 ^ 2将被计算为3 ^（2/1）*（3 ^ 2/1），这里无需将其乘以3。我希望很清楚

Answer 3

public static double pow(int a, int pow) {
    if (pow == 0)
        return 1;
    if (pow == 1)
        return a;
    if (pow == -1)
        return 1. / a;
    if (pow > 1)
        return a * pow(a, pow - 1);
    return 1. / (a * pow(a, -1 * (pow + 1)));
}

Answer 4

将X视为数字，将n视为幂，如果两者均为正整数

    public static int power(int n, int X) {

            if (n == 0) {
                return 1;
            } else if(n == 1) {
                return X;
            } else {
                return X * power(n-1, X);
            }
    }

Answer 5

尽管其他人为您提供了代码方面的解决方案，但我想着重介绍为什么您的代码无法正常工作。

递归是一种编程方法，其中方法（函数）调用自身。所有递归都具有两个特定特征：

在调用自身时，它可以解决一个较小的问题。在您的示例中，为了将X提升为幂N，该方法使用参数X和N-1递归调用自身，即在以后的每个步骤中解决了一个较小的问题。
最终会有一个微不足道的问题版本，这样递归就可以解决它而无需调用自身并返回。这称为基本情况。

如果您熟悉数学归纳法，那么递归就是它的编程等效项。

上面的第二点是您的代码所缺少的。您的方法永远不会返回任何数字。在将数字加幂的情况下，基本情况是解决数字0的问题，因为对任何幂加零都会产生1，因此代码无需再次调用自身来解决此问题。

因此，正如其他人已经建议的那样，您需要对代码进行两项更正：

为该方法添加返回类型。
明确说明基本情况。

Answer 6

尝试--

public class HelloWorld{

    public long powerfun(int n,int power,long value){
        if(power<1){
            return value;
        }
        else{
            value = value * n;
            return powerfun(n,power-1,value);
        }
    }

     public static void main(String []args){
         HelloWorld hello = new HelloWorld();
        System.out.println(hello.powerfun(5,4,1));
     }
}

Answer 7

这有望满足您的解决方案。我试图添加注释以向您解释逻辑。

//Creating a new class
public class RecursivePower {

    // Create the function that will calculate the power
    // n is the number to be raised to a power
    // x is the number by which we are raising n
    // i.e. n^x
    public static int power(int n, int x){
        // Anything raised to the 0th power is 1
        // So, check for that
        if (x != 0){
            // Recursively call the power function
            return (n * power(n, x-1));

        // If that is true...    
        }else{
            return 1;
        } //end if else
    } //end power

    // Example driver function to show your program is working
    public static void main(String[] args){
        System.out.println("The number 5 raised to 6 is " + power(5,6));
        System.out.println("The number 10 raised to 3 is " + power(10,3));
    } //end psvm

} //end RecursivePower

Answer 8

让我们重新编写您的函数：

static public void power(int n, int X) {

    System.out.print( + " ");

    if (n>0) {
        power(n-1, X);
    }
}

首先，让我们将void更改为int。

此后，当n等于1时，我们返回结果为X，因为X^1 = X：

static public int power(int n, int X) {

    if (n>1) {
        return X * power(n-1, X);
    }
    return X;
}

Answer 9

        Scanner s = new Scanner(System.in) ;
        System.out.println("Enter n");
        int n = s.nextInt();
        System.out.println("Enter x");
        int x =s.nextInt();
        if (n>0){
            double pow =Math.pow(n,x);
            System.out.println(pow);
        }

如何递归计算加幂的数字？

9 个答案: