Java 类似 MathPow 的方法在效率上具有迭代和递归的解决方案-作业

Question

我的作业有问题，我需要帮助！

问题一：

完成下面的 Java 方法，以便 raiseToPower(x,n) 将数字 x 提升到 integer 幂 n（即计算值 xn ）。 请记住 xn = 1/xn，并且 x0 = 1。

您应该以尽可能少的步骤（即 O(log n) 时间）执行此操作。

给出一个非递归（迭代）的解决方案：

这是我的解决方案：

    public static double raiseToPower (double x, int n) {
double res=1;
     boolean neg=false;
     if(n<0)
     {
         neg=true;

     }
     if(n>0)

         for (int i=0;i<n;i++) {
             res = res * x;
         }
             if(neg==true) {
                 n=n*-1;
                 for (int i=0;i<n;i++) {


                     res = res * x;
                 }
                   res=1/res;
             }


             return res;
}

但这是不正确的，因为不是效率

例如，这是我的错误： 52.49 的 9 次方分 9 步求解，但它可以分 4 步完成 89.89 的 75 次方分 75 步求解，但它可以分 7 步完成 78.57 的幂63 分 63 步解决，但本可以分 6 步完成 70.17 的 44 次方分 44 步解决，但本可以分 6 步完成

注意：不得在方法 java.lang.MathPow 中使用

问题2：

我需要编写与问题 1完全相同的代码，但需要递归

这是我的问题：给出一个递归解决方案：

这是我的代码：

     public static double raiseToPower (double x, int n) {
ouble dev=0.0;
        if (n == 0) {
            return 1;
        } else {
            if (n < 0) {
              double  count= raiseToPower (x, n+1);
                dev=count*x;
                return 1 / raiseToPower (x, -n);
            }
            if (n > 0) {
             double  count= raiseToPower (x, n-1);
             dev=count*x;



            }

        }
        return dev;
}

这段代码是正确的，但不是效率。

这是我的错误，例如：

53.31 的 44 次方分 44 步解决，但它可以在 6 步中完成 6.90 的 74 次方通过 74 步解决，但它可以在 7 步中完成 80.76 的 76 次方在 76 步中解决, 但它可以在 7 步中完成 51.44 的 86 次方在 86 步中求解，但它可以在 7 步中完成 76.26 的 50 次方在 50 步中求解，但它可以在 6 步中完成63.53 的 93 次方分 93 步求解，但本可以分 7 步完成

注意：不得在方法 java.lang.MathPow 中使用

感谢大家的帮助和解决这两个问题！

Answer 1

您可以通过将 n 分解为 2 的幂来计算 O(logN) x^n，如下所示：

9 = 1+8

15= 1+2+4+8

因此，x^9= (x^1)*(x^8)。

为了分解 n 的 2 次幂，您可以使用位运算符。 像这样：n&pow2 意味着你在 N 和 pow2 之间进行“与”运算，这意味着如果 n 有一个位 1 并且 pow2 也有那个位 1，那么结果将是非零的。 鉴于 pow2 必须有一个位 1（它是 2 的幂），您基本上可以检查 n 的每一位。 因此，您正在以 2 的幂分解 n 并且您可以简单地保持一个 powx 周围，这意味着 x^(pow2) 当您循环遍历 2 的幂时，然后在您发现 n 确实由以下组成时将其乘以 res 2的幂。

所以我们可以为第一个解决方案编写这段代码：

  public static double raiseToPower (double x, int n) {
    double res=1;
    double powx=x;
    int pow2=1;
    boolean neg=false;
    if(n<0)
    {
      neg=true;
      n=n*-1;
    }
    while(n!=0) {
      if((n&pow2)!=0)
      {
        res=res*powx;
        n=n-pow2;
      }
      powx=powx*powx;
      pow2=pow2*2;
    }
    if(neg==true)
      res=1/res;
    return res;
  }

这里有更多关于按位运算符的文章： https://www.tutorialspoint.com/java/java_basic_operators.htm

同样，您可以修改递归代码以在 O(logN) 中获取它。

这将是递归代码：

  public static double raiseToPower(double x, int n)
{
    boolean neg= false;
    double res=1;
    if(n<0)
    {
      neg=true;
      n=-n;
    }

    if (n == 0) return 1;
    if (n % 2 == 0)
    {
      res= raiseToPower(x, n / 2);
      res=res*res;
    }
    else
    {
      res= x * raiseToPower(x, n - 1);
    }
    if(!neg)
      return res;
    return 1/res;
}

Answer 2

public class ExponentialCalculator {

    public static void main(String[] args) {
        double x = 2;
        int n = -4;
        System.out.println(raiseToPower(x, n));
    }

    //Divide and Conquer method
    public static double raiseToPower (double x, int n) {
        if(n==0) {
            return 1;
        }
        double temp = raiseToPower(x, n/2) * raiseToPower(x, n/2);
        if(n%2==0) {
            return n > 0 ? temp: 1/temp;    
        }
        else {
            return n > 0 ? x * temp: 1/(x * temp);
        }
    }
}

结果 0.0625

复杂度对数（n）