Java 我只是增加了反转数字的复杂性吗？

}

我确实知道

reverse=reverse+（int）（mod*java.lang.Math.pow（10，numfodigits-1））可以替换为
reverse=mod+（reverse*10）

我想知道我是否只是通过计算总位数和应用幂增加了一个简单程序的复杂性

注意：请假设orig可以作为用户的输入，可以是任意位数。我只为实验而硬编码。
计算乘法和加法：

假设f（x）=an*x^n+an-1*x^n-1+…+a1*x+a0

1.如果通过逐项计算来计算f（x），

它需要（n+1）+n+（n-1）+…+1+0=（n+1）（n+2）/2次乘法和n次加法。

2.如果通过
n=n*10+mod
计算f（x），

它将需要n次乘法和n次加法

当然，如果
pow（）
有一些优化，比如“分而治之”，那么
pow（）
的复杂度应该是O（logN）。
计算乘法和加法时间：

假设f（x）=an*x^n+an-1*x^n-1+…+a1*x+a0

1.如果通过逐项计算来计算f（x），

它需要（n+1）+n+（n-1）+…+1+0=（n+1）（n+2）/2次乘法和n次加法。

2.如果通过
n=n*10+mod
计算f（x），

它将需要n次乘法和n次加法

当然，如果
pow（）
有一些优化，比如“分而治之”，那么
pow（）
的复杂性应该是O（logN）。
您没有增加复杂性。。。但你确实让它变慢了。表达式
pow（10，numfodigits-1）
将大大慢于
reverse=mod+（reverse*10）

由于浮点不精确，使用
Math.pow
而不是整数乘法的计算也可能不准确。一个
double
只有52位精度，而
long
只有63位精度。在本例中，这可能不适用，但需要注意的是，一般来说，您没有增加复杂性。。。但你确实让它变慢了。表达式
pow（10，numfodigits-1）
将大大慢于
reverse=mod+（reverse*10）

由于浮点不精确，使用
Math.pow
而不是整数乘法的计算也可能不准确。一个
double
只有52位精度，而
long
只有63位精度。在本例中，这可能不适用，但值得警惕，一般来说，这可能是迭代次数较少的最佳方法

public class HelloWorld{

 public static void main(String []args){

    int  orig=103, reverse=0, mod;
    int numOfDigits=0;
    int n = orig;

    while (n>0){
        n /= 10;
        numOfDigits++;
    }
    n = orig;
    while (n > 0){
        mod = n % 10;
        reverse = reverse + (int)(mod * java.lang.Math.pow(10, numOfDigits-1));
        numOfDigits--;
        n /= 10;
    }

System.out.println("Reversed is : " + reverse);
 }

这可能是迭代次数较少的最佳方法&复杂性：

public class HelloWorld{

 public static void main(String []args){

    int  orig=103, reverse=0, mod;
    int numOfDigits=0;
    int n = orig;

    while (n>0){
        n /= 10;
        numOfDigits++;
    }
    n = orig;
    while (n > 0){
        mod = n % 10;
        reverse = reverse + (int)(mod * java.lang.Math.pow(10, numOfDigits-1));
        numOfDigits--;
        n /= 10;
    }

System.out.println("Reversed is : " + reverse);
 }

这是猜测。事实上，真正的实现根本不是这样工作的；看见但不要相信我的话：看看源代码！这是猜测。事实上，真正的实现根本不是这样工作的；看见但不要相信我的话：看看源代码！