Java 计算整数的幂

Java中还有其他方法计算整数的幂吗

我现在使用

Math.pow（a，b）

，但它返回一个

double

，这通常需要大量的工作，当您只想使用

int

s时，它看起来就不那么干净了（通电后也总是会产生

int

）

---

在Python中有像

a**b

这样简单的东西吗？

没有，没有像

a**b

下面是一个简单的循环，如果您希望避免重复：

long result = 1;
for (int i = 1; i <= b; i++) {
   result *= a;
}

---

整数只有32位。这意味着它的最大值是

2^31-1

。正如你所看到的，对于非常小的数字，你很快就会得到一个不再用整数表示的结果。这就是为什么

Math.pow

使用

double

如果需要任意整数精度，请使用。但它的效率当然更低。

import java.util.*；
import java.util.*;

public class Power {

    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int num = 0;
        int pow = 0;
        int power = 0;

        System.out.print("Enter number: ");
        num = sc.nextInt();

        System.out.print("Enter power: ");
        pow = sc.nextInt();

        System.out.print(power(num,pow));
    }

    public static int power(int a, int b)
    {
        int power = 1;

        for(int c = 0; c < b; c++)
            power *= a;

        return power;
    }

}

公共阶级权力{
公共静态void main（字符串参数[]）
{
扫描仪sc=新的扫描仪（System.in）；
int num=0；
int-pow=0；
整数幂=0；
系统输出打印（“输入编号：”）；
num=sc.nextInt（）；
系统输出打印（“输入电源：”；
pow=sc.nextInt（）；
系统输出打印（功率（num，pow））；
}
公共静态整数功率（整数a、整数b）
{
整数幂=1；
for（int c=0；c

最佳算法基于a^b的递归幂定义

long pow (long a, int b)
{
    if ( b == 0)        return 1;
    if ( b == 1)        return a;
    if (isEven( b ))    return     pow ( a * a, b/2); //even a=(a^2)^b/2
    else                return a * pow ( a * a, b/2); //odd  a=a*(a^2)^b/2

}

操作的运行时间为O（logb）。

---

参考资料：

谷歌番石榴有整数的数学实用程序。

我设法修改了（边界、偶数检查、负数检查）Qx_uuuuuu_uuu_uuuu的答案。使用风险自负。0^-1、0^-2等。。返回0

private static int pow(int x, int n) {
        if (n == 0)
            return 1;
        if (n == 1)
            return x;
        if (n < 0) { // always 1^xx = 1 && 2^-1 (=0.5 --> ~ 1 )
            if (x == 1 || (x == 2 && n == -1))
                return 1;
            else
                return 0;
        }
        if ((n & 1) == 0) { //is even 
            long num = pow(x * x, n / 2);
            if (num > Integer.MAX_VALUE) //check bounds
                return Integer.MAX_VALUE; 
            return (int) num;
        } else {
            long num = x * pow(x * x, n / 2);
            if (num > Integer.MAX_VALUE) //check bounds
                return Integer.MAX_VALUE;
            return (int) num;
        }
    }

private静态整数功率（整数x，整数n）{
如果（n==0）
返回1；
如果（n==1）
返回x；
如果（n<0）{//总是1^xx=1&&2^-1（=0.5-->~1）
如果（x==1 | |（x==2&&n==1））
返回1；
其他的
返回0；
}
如果（（n&1）=0）{//是偶数
长数值=功率（x*x，n/2）；
if（num>Integer.MAX\u值）//检查边界
返回Integer.MAX_值；
返回（int）num；
}否则{
长数值=x*pow（x*x，n/2）；
if（num>Integer.MAX\u值）//检查边界
返回Integer.MAX_值；
返回（int）num；
}
}

Guava的数学库提供了两种计算精确整数幂的方法：

计算b到第k次方的幂，并覆盖溢出

除了在溢出时抛出算术异常之外，它是相同的

就个人而言，

checkedPow（）

满足了我对整数求幂的大部分需求，并且比使用双精度和舍入等更干净、更安全。在我想要幂函数的几乎所有地方，溢出都是一个错误（或不可能，但我想知道不可能是否可能）

---

如果你想得到一个

long

结果，你可以使用相应的方法并传递

int

参数。

你可以简单地使用前面使用的

Math.pow（a，b）

，然后在前面使用

（int）

转换它的值。下面可以作为一个例子

int x = (int) Math.pow(a,b);

其中

a

和

b

可以是

double

或

int

值。 这将根据需要将其输出转换为整数值。

用于计算幂的重复平方算法的简单（不检查溢出或参数的有效性）实现：

/** Compute a**p, assume result fits in a 32-bit signed integer */ 
int pow(int a, int p)
{
    int res = 1;
    int i1 = 31 - Integer.numberOfLeadingZeros(p); // highest bit index
    for (int i = i1; i >= 0; --i) {
        res *= res;
        if ((p & (1<<i)) > 0)
            res *= a;
    }
    return res;
}

/**计算**p，假设结果符合32位有符号整数*/
内部功率（内部a、内部p）
{
int res=1；
int i1=31-整数。numberOfLeadingZeros（p）；//最高位索引
对于（int i=i1；i>=0；--i）{
res*=res；
如果（（p&（1）与Python不同（在Python中，幂可以通过a**b计算），JAVA没有实现两个数字幂的结果的快捷方式。
Java在Math类中有一个名为pow的函数，该函数返回一个双精度值

double pow(double base, double exponent)

但您也可以使用相同的函数计算整数的幂。在下面的程序中，我做了相同的操作，最后将结果转换为整数（类型转换）。如下示例：

import java.util.*;
import java.lang.*; // CONTAINS THE Math library
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n= sc.nextInt(); // Accept integer n
        int m = sc.nextInt(); // Accept integer m
        int ans = (int) Math.pow(n,m); // Calculates n ^ m
        System.out.println(ans); // prints answers
    }
}

或者，
java.math.biginger.pow（int-exponent）
返回一个biginger，其值为（this^exponent）。该指数是一个整数而不是一个biginger。示例：

import java.math.*;
public class BigIntegerDemo {
public static void main(String[] args) {
      BigInteger bi1, bi2; // create 2 BigInteger objects          
      int exponent = 2; // create and assign value to exponent
      // assign value to bi1
      bi1 = new BigInteger("6");
      // perform pow operation on bi1 using exponent
      bi2 = bi1.pow(exponent);
      String str = "Result is " + bi1 + "^" +exponent+ " = " +bi2;
      // print bi2 value
      System.out.println( str );
   }
}

当它是2的幂时，请记住，您可以使用简单快速的移位表达式
1使用以下逻辑来计算a的n幂

通常，如果我们想计算a的n次幂，我们将把“a”乘以n次。这种方法的时间复杂度为O（n）
将幂n除以2，计算指数=乘以“a”直到n/2。将值加倍。现在时间复杂度降低到O（n/2）

公共整数计算能力1（整数a、整数b）{
如果（b==0）{
返回1；
}
int val=（b%2==0）？（b/2）：（b-1）/2；
内部温度=1；
对于（int i=1；ibase是要加电的数字，n是幂，如果n为0，我们返回1，如果n为1，我们返回base，如果不满足条件，我们使用公式base*（powerN（base，n-1））例如：2提升到使用此公式是：2（base）*2（powerN（base，n-1））

pow方法存在一些问题：

我们可以将（y&1）==0；替换为y%2==0

按位操作总是更快
您的代码总是递减y并执行额外的乘法，包括y为偶数的情况。最好将这部分放在else子句中

public static long pow(long x, int y) {
        long result = 1;
        while (y > 0) {
            if ((y & 1) == 0) {
                x *= x;
                y >>>= 1;
            } else {
                result *= x;
                y--;
            }
        }
        return result;
    }

Apache有。
导入java.util.Scanner；
类解决方案{
公共静态void main（字符串[]args）{
Sca
public  int calculatePower1(int a, int b) {
    if (b == 0) {
        return 1;
    }

    int val = (b % 2 == 0) ? (b / 2) : (b - 1) / 2;

    int temp = 1;
    for (int i = 1; i <= val; i++) {
        temp *= a;
    }

    if (b % 2 == 0) {
        return temp * temp;
    } else {
        return a * temp * temp;
    }
}

public int power(int base, int n){
   return n == 0 ? 1 : (n == 1 ? base : base*(power(base,n-1)));
}

public static long pow(long x, int y) {
        long result = 1;
        while (y > 0) {
            if ((y & 1) == 0) {
                x *= x;
                y >>>= 1;
            } else {
                result *= x;
                y--;
            }
        }
        return result;
    }