n的阶乘会溢出？解决超大数字阶乘溢出问题。

在我们面试时通常会遇到阶乘的问题，当然最简单的就是运用递归，循环所求的阶乘数：

不多数，直接上代码：

 

/**  
 * 实现10的阶乘 
 * @author fx * */  
public class JieCheng {  
  public static void main(String[] args) {    
    System.out.println(getFactorialSum(10)+"");//通过循环实现阶乘   
    int sum=1,n=10;   
    for(int i=1;i<=n;i++){    
      sum=sum*i;   
    }  
    System.out.println(sum);  
  }  
  //通过递归实现阶乘  
  private static int getFactorialSum(int n){   
    if(n==1||n==0){     
      return 1;    
    }else{     
      return getFactorialSum(n-1)*n;   
    }  
  }  
}

当我们到13的阶乘时，则会计算不出，这时我们可以把int类型转换成long类型，但是，当计算到很大的数字时，也会运行异常。

这时，我们需要转换一下思维。这里运用 采用 “数组进位” 算法。在超越计算机变量取值范围的情况下，将多位数相乘转化为一位数相乘。如11！=39916800，若需求12的阶乘，则需要将39916800与12相乘，可利用乘法分配率。

 

 

理论上讲，只要计算机内存空间允许就可以保存任意多位的阶乘结果，不再受变量的取值范围的限制，只受到操作系统的寻址能力和计算机内存的限制。如果要求的阶乘数字很大则可以将数组定义为 long 类型，以避免在计算单位数的乘积时出现溢出的情况。不多说了，上代码：

/**
 * Created by fx on 2017/7/20.
 */
public class BigInteger
{
    /**
     * 计算进位
     * @param bit	 数组
     * @param pos 用于判断是否是数组的最高位
     */
    private void carry(int[] bit, int pos)
    {
        int i ,carray = 0;
        for(i = 0 ; i<= pos ;i++)//从0到pos逐位检查是否需要进位
        {
            bit[i] += carray;//累加进位
            if(bit[i] <= 9)	 //小于9不进位
            {
                carray = 0;
            }else if(bit[i] > 9 && i < pos) //大于9但不是最高位
            {
                carray = bit[i]/10;   //保存进位值
                bit[i] = bit[i]%10;   //得到改位的一位数
            }
            else if(bit[i] > 9 && i >= pos) //大于9且是最高位
            {
                while(bit[i] > 9)     //循环向前进位
                {
                    carray = bit[i]/10; //计算进位值
                    bit[i] = bit[i]%10; //当前的一位数
                    i++;
                    bit[i] = carray;
                }
            }

        }
    }

    /**
     * 大整数阶乘
     * @param bigInteger 所计算的大整数
     */
    private  void bigFactorial(int bigInteger)
    {
        int pos =0;//
        int digit;//数据长度
        int a , b ;
        int m = 0 ;//统计输出位数
        int n  = 0 ;//统计输出行数
        double sum = 0;//阶乘位数
        for(a = 1 ; a <= bigInteger ; a ++)//计算阶乘位数
        {
            sum += Math.log10(a);
        }
        digit = (int)sum + 1;//数据长度

        int[] fact = new int[digit];//初始化一个数组
        fact[0]  = 1;//设个位为 1

        for(a = 2 ; a <= bigInteger ; a++ )//将2^bigInteger逐个与原来的积相乘
        {
            for(b = digit-1 ; b >= 0 ; b--)//查找最高位{}
            {
                if( fact[b]  !=  0 )
                {
                    pos = b ;//记录最高位
                    break;
                }
            }

            for(b = 0; b <= pos ; b++)
            {
                fact[b] *= a ;//每一位与i乘
            }
            carry(fact,pos);
        }

        for(b = digit-1 ; b >= 0 ; b --)
        {
            if(fact[b] != 0)
            {
                pos = b ;//记录最高位
                break;
            }
        }
        System.out.println(bigInteger +"阶乘结果为：");
        for(a = pos ; a >= 0 ; a --)//输出计算结果
        {
            System.out.print(fact[a]);
            m++;
            if(m % 5 == 0)
            {
                System.out.print(" ");
            }
            if(40 == m )
            {
                System.out.println("");
                m = 0 ;
                n ++;
                if(10 == n )
                {
                    System.out.print("\n");
                    n = 0;
                }
            }
        }
        System.out.println("\n"+"阶乘共有: "+(pos+1)+" 位");

    }

    public void doBigFactorial(int bigInteger)
    {
        int timeBegin=(int) System.currentTimeMillis();
        this.bigFactorial(bigInteger);
        int timeFinishi=(int) System.currentTimeMillis();
        int time = timeFinishi-timeBegin;
        System.out.println("计算耗时: " + time +"毫秒" );
    }

    public static void main(String[] args)
    {
        BigInteger bi = new BigInteger();
        bi.doBigFactorial(100000);
    }
}

 

此处计算的100000的阶乘（当然可以修改成其他数字）。

结果如下：