Question

所以我试着学习递归（我知道在这种情况下递归是没有必要的）

我已经编写了这个方法，可以使用

public static int method(int number) {
    if(number == 0) {
        return 1;
    }
    else {
        return (int)Math.pow(2,number) + method(number-1);
    }
}

这非常适合将2的幂从0加到数字，但我想知道是否有办法用另一个递归方法调用替换Math.pow()

Answer 1

您可以将其用作递归幂函数：

public static int powerOf2(int number) {
    if (number == 0) {
        return 1;
    } else {
        return 2 * powerOf2(number - 1);
    }
}

或者，作为一个单体：

return number > 0 ? 2 * powerOf2(number - 1) : 1;

Answer 2

您应该定义另一个递归方法来递归计算Math.pow（2，n）。但是我建议做2位移位操作来快速计算Math.pow（2，n）。例如，移位2＆lt;＆lt; （n-1）会在这里滚刀。

Answer 3

如果你想学习递归，请参考Fibonacci系列的一个众所周知的例子。

public int getNthFibonacci( int n )
    {
        if ( n == 1 || n == 2 ) 
            return 1;

      else
        return getNthFibonacci( n-1 ) + getNthFibonacci( n-2 );
    }

public static void main(String[] args){

        Recursion myRecursor = new Recursion();
        System.out.println( myRecursor.getNthFibonacci(5) );

    }

但在你的情况下，也可以通过for循环轻松完成。

public static void main(String[] args) {

       int sum = 0;     
        for (int number = 20; number>0; number--)
        {
            sum += Math.pow(2,number);
        }

        System.out.println(sum);

}

Answer 4

更通用的解决方案：

public static int pow (int base, int ex) {
    if (ex == 0) {
        return 1;
    } else if (ex == 1) {
        return base;
    } else if(ex > 1) {
        return (pow(base, ex - 1) * base);
    } else {
        return pow(base, ex + 1) / base;
    }
}

这将处理传递的值为整数的所有可能情况。

Answer 5

也许距离严格的问题有点远，你的问题是计算几何系列的总和，其中是连续术语之间具有恒定比率的系列。

你的第一个元素等于1（2 pow 0）并且你的比率等于2.所以不要使用任何递归，你可以使用普通的，众所周知的，等式：

public long computGemetricSeries(int n) {
  long firstElem = 1;
  long ratio = 2;

  return (firstElem * (1 - Math.pow(ration,n)) / (1 - ratio));
}

或者一般术语（不仅是权力o 2）：

public long computGeometricSeries(int n, double ration, double firstElem) {
   return (firstElem * (1 - Math.pow(ration,n)) / (1 - ration));
}

如果你真的想要递归，你可以将Math.pow(ration,n)更改为其他答案提出的某些递归函数。

我认为这对你的问题的解决方案没什么帮助，但这将是一个很好的知识答案。

Answer 6

public class ComputePowerUsingRecursion {

    public static void main(String[] args) {    
        System.out.println(computePower(2,5));  // Passing 2 for power of 2
        System.out.println(computePower(2,-5)); // Number would be +ve or -ve
    }

    /**
     * <p>Compute power</p>
     * 
     *  p(x,n)  =  1              if(x=0)
     *          =  x*p(x,n-1)     if(n>0)
     *          =  (1/x)*p(x,n+1) if(n<0)  
     * @param x
     * @param n
     * @return
     */
    public static double computePower(double x, double n){
        //base case
        if(n==0){
            return 1;
        }else if(n>0){   //recursive condition for postive power
            return x*computePower(x, n-1);
        }else if(n<0){  //recursive condition for negative power
            return (1/x)*computePower(x, n+1);
        }else{ 
            return -1;
        }
    }
}

Answer 7

public static void main (String[] args){
    Integer output = 0;
    output = sumOfThePower(end, 1, 1); //input the number you like at 'end' to get the sum
    System.out.println(output);
}
public static Integer sumOfThePower (int end, int start, int mul){
if (start <= end){
    mul =2 * mul;
    return mul + sumOfThePower(end, start + 1, mul);
}
else{
    return 1;
}
}

用于求和2的幂的Java递归方法，从0到N.

7 个答案: