用Java来实现一个数的阶乘

[liuhao0720]

用Java来实现一个数的阶乘，怎么去实现呀？代码怎

么写呀？

[marf_cn]

public static void main(String[] args) {
long i=1;
while(true){
Factorial4.factorial(5000).toString();
if(i%100==0){
System.out.println(i);
}

i++;
}

}
}
class Factorial4{
protected static ArrayList table = new ArrayList();
static{ table.add(BigInteger.valueOf(1));}

public static synchronized BigInteger factorial(int x){
for(int size=table.size();size<=x;size++){
BigInteger lastfact= (BigInteger)table.get(size-1);
BigInteger nextfact= lastfact.multiply(BigInteger.valueOf(size));
table.add(nextfact);
}
return (BigInteger) table.get(x);
}

[starc]

还是别忘了大数,此题考的是数据结构

[straing]

package safe1;

import java.util.Scanner;

public class jiechen {
public static void main(String []arg){
int w=1;
/*
下面两行的功能是输出你所需要计算阶乘的数i
*/
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
for(int k=i;k>0;k--)
w=w*k;
System.out.println(w);
}

}

[junyao100]

不错，用的递归

[junyao100]

public class A {

public static long cal(int i){
if (i == 1)
return 1;
else
return cal(i-1) * i;
}

public static void main(String[] argv){
System.out.println(A.cal(5));
}

}
是不是在递归里面少了一个i--呢？请指教

[lidonghaihome]

不少i--,在调用cal的时候，传递的参数为i-1这里就直接进行了参数转换。

[aa870816]

感觉还是非递归的好一点啊，如果数字比较大的话，递归方法会很慢的~~~

[hn1232]

来个非递归的~

public class Factorial {

    public static long getFactorial(int num){
        long temp = 1;
        for(int i=1;i<=num;i++){
            temp *= i;
        }
        return temp;
    }

    public static void main(String[] args){
      System.out.println(getFactorial(0));
      System.out.println(getFactorial(5));
    }
}

[冰思雨]

简单写两个

public static long cal(int n){
  long result = 1;
  for(int i=n;i>0;i--){
    result *= i;
  }
  return result;
}

public static long cal(int n){
  if(n==1)return 1;
  return n*cal(n-1);
}

[zl3450341]

[Quote=引用 1 楼 shiyiwan 的回复:]
Java codepublicclass A {publicstaticlong cal(int i){if (i==1)return1;elsereturn cal(i-1)* i;
}publicstaticvoid main(String[] argv){
System.out.println(A.cal(5));
}

}

总有人不好好做作业 +_+
[/Quote]

。。。总有人不好好做作业

[火龙果被占用了]

import java.math.BigInteger;

public class Test {

public static void main(String[] args) {
BigInteger x = factorial(30);
System.out.println(x);
}

public static BigInteger factorial(int num) {
if(num < 0) {
throw new IllegalArgumentException("num must be signless integral.");
}
if(num < 2) {
return BigInteger.ONE;
}

// 小于等于 16 时可以使用 int 进行计算
if(num <= 16) {
return intFractorial(num);
}

// 小于等于 20 时可以使用 long 进行计算
if(num <= 20) {
return longFractorial(num);
}

// 大于 20 时需要采用 BigInteger 进行计算
return bigIntegerFactorial(num);
}

private static BigInteger intFractorial(int num) {
int result = 1;
while(num > 0) {
result *= num--;
}
return BigInteger.valueOf(result);
}

private static BigInteger longFractorial(int num) {
long result = 1L;
while(num > 0) {
result *= num--;
}
return BigInteger.valueOf(result);
}

private static BigInteger bigIntegerFactorial(int num) {
BigInteger result = longFractorial(20);
while(num > 20) {
result = result.multiply(BigInteger.valueOf(num--));
}
return result;
}
}

[wym2005em]

好好学习

[sunzerui]

问题是大数怎么办？
问1000或10000的阶层怎么求？
怎么保存大数呢？

[KingWolfOfSky]

确实，
如果面试Java，火龙果的答案是正解
如果考算法，模拟大数计算是正解

[kmkjwjf]

用数组存放。在C#专区有人给出了很详细的解答

[btq123]

火龍果的解法不錯。

[nihuajie05]

[Quote=引用 19 楼 sunzerui 的回复:]
问题是大数怎么办？
问1000或10000的阶层怎么求？
怎么保存大数呢？
[/Quote]
Java 明明有支持的大数据类型，干吗还要自己去管理。我是没这个自信编写的代码与源码比拼的效率。

[tq02ksu]

把10000以下的全都算好保存起来, 用的时候直接拿, 10000以上的现算.
保证有效率.

[tq02ksu]

10000以内的数用啥算效率也差不多少, 如果说运算次数多的话做一个缓存更合理, 所以倒不如都用一样的BigInteger.

[yanliang_xt]

[Quote=引用 7 楼 bao110908 的回复:]
import java.math.BigInteger;

public class Test {

    public static void main(String[] args) {
        BigInteger x = factorial(30);
        System.out.println(x);
    }
   
    public static BigInteger factorial(int num) {
        if(num < 0) {
            throw new IllegalArgumentException("num must be signless integral.");
        }
        if(num < 2) {
            return BigInteger.ONE;
        }
       
        // 小于等于 16 时可以使用 int 进行计算
        if(num <= 16) {
            return intFractorial(num);
        }
       
        // 小于等于 20 时可以使用 long 进行计算
        if(num <= 20) {
            return longFractorial(num);
        }
       
        // 大于 20 时需要采用 BigInteger 进行计算
        return bigIntegerFactorial(num);
    }
   
    private static BigInteger intFractorial(int num) {
        int result = 1;
        while(num > 0) {
            result *= num--;
        }
        return BigInteger.valueOf(result);
    }
   
    private static BigInteger longFractorial(int num) {
        long result = 1L;
        while(num > 0) {
            result *= num--;
        }
        return BigInteger.valueOf(result);
    }
   
    private static BigInteger bigIntegerFactorial(int num) {
        BigInteger result = longFractorial(20);
        while(num > 20) {
            result = result.multiply(BigInteger.valueOf(num--));
        }
        return result;
    }
}
[/Quote]

注意这里有一个小错误：

        // 小于等于 16 时可以使用 int 进行计算
        if(num <= 16) {
            return intFractorial(num);
        }

此处应为小于等于12才对