关于N的阶乘(n!)的java算法实现

很多公司面试都会有一个问题，就是求N阶乘，主要是考查一些编程的基础知识如循环、类型的最大长度、递归等。

例如最简单的实现是：

public void factorial(int n){

long result = 1;

for(int i=0;i<n;i++){

  result = result*i;

}

}

但是，这个简单的实现可能会出现问题，   n一大就会超过long的最大值，从而导致错误。

而且随着n的增大，数会越来越大，即使是double也无法满足计算的需要。

为了解决这个问题，唯一的办法就是使用字符串，才能避免类型越界和数字大的问题，下面是基本的算法思路：

1）将数字用科学计数法表示，例如1234可以表示位1*1000+2*100+3*10+4*1

1000是10的3次方，100是10的2次方，10是10的1次方，1是10的0次方，依次类推。

2)两个多位数（10以上）相乘拆分成多次乘法，然后进行相加。

3）两个数相乘可以表示成两个数进行表示

4)用IntegerString[]数组表示一个数

程序如下：

定义类：

//表示一个数字，使用科学计数法。如500表示IntegerString(5,2)

public class IntegerString {
    private int number = 0;//数字
    private int length = 0;//10的length次方
    /** Creates a new instance of IntegerString */
    public IntegerString(int number,int length) {
        this.number = number;
        this.length = length;
    }
    public int getNumber(){
        return this.number;
    }
    public int getLength(){
        return this.length;
    }
}

/**

  两个数相乘，结果用两个数来表示，一个是高位，一个是低位

**/

public class MultiplyResult {
   
    private IntegerString high;
    private IntegerString low;
    /** Creates a new instance of MultiplyResult */
    public MultiplyResult(IntegerString a,IntegerString b) {
        int result = a.getNumber()*b.getNumber();
        int length = a.getLength()+b.getLength();
        if(result>=10){
            high = new IntegerString(result/10,length+1);
            low = new IntegerString(result%10,length);
        }else{
            high = new IntegerString(result,length);
            low = new IntegerString(0,length-1);
        }
    }
    public String toString(){ //打印方便，以便调试
        StringBuffer sb = new StringBuffer();
        sb.append(high.getNumber());
        sb.append(low.getNumber());
        for(int i=0;i<low.getLength();i++)
            sb.append("0");
        return sb.toString();
    }
    public IntegerString getHigh(){
        return high;
    }
    public IntegerString getLow(){
        return low;
    }
   
}

public class Factorial{

//由大到小,由高到低，将一个字符的数表示成科学计数法
private IntegerString[] getIntegerString(String str){
        IntegerString[] is = new IntegerString[str.length()];
        for(int i=0;i<str.length();i++){
            char ch = str.charAt(i);
            int number = Character.getNumericValue(ch);
            is[i] = new IntegerString(number,str.length()-1-i);
        }
        return is;
}

//获得数的最高位
    private int getMaxLength(IntegerString[] a){
        int max = 0;
        for(int i=0;i<a.length;i++){
            if(a[i].getLength()>max)
                max = a[i].getLength();
        }
        return max;
    }

    //一个数与单个数字相乘
    private IntegerString[] singleMultiply(IntegerString[] old,IntegerString gene){
        MultiplyResult[] mr = new MultiplyResult[old.length];
        for(int i=0;i<old.length;i++){
            mr[old.length-1-i] = new MultiplyResult(old[i],gene);
           // System.out.println(mr[old.length-1-i]);
        }
       
        //mr是从最低位到最高位
        java.util.ArrayList arrays = new java.util.ArrayList();
        int carry = 0;
        int maxLength = mr[mr.length-1].getHigh().getLength(); //获得最高位的长度
        for(int i=0;i<=maxLength;i++){//从个位到最高位一次加，如果有进位，那么存放到carry中
            int number = carry;
            for(int j=0;j<mr.length;j++){
               if(mr[j].getLow().getLength()==i)
               {
                   number+=mr[j].getLow().getNumber();
               }
               if(mr[j].getHigh().getLength()==i){
                   number+=mr[j].getHigh().getNumber();
               }  
            }
            if(number>=10){ //如果有进位，取余数，如果没有，取本身
                arrays.add(new IntegerString(number%10,i));
                carry=1;
            }else{
                arrays.add(new IntegerString(number,i));
                carry=0;
            }
        }
        if(carry==1){ //如果还有进位，那么加入到最高位
            arrays.add(new IntegerString(carry,maxLength+1));
        }
       IntegerString[] results = new IntegerString[arrays.size()];
       java.util.Iterator ii = arrays.iterator();
       int index=0;
       while(ii.hasNext()){
           results[index++] = (IntegerString)ii.next();
       }
       return results;
    }

    private void print(IntegerString[] a){
       System.out.println(getNumberic(a));
    }
    //将数字由IntegerString[]数组转换成字符串
    private String getNumberic(IntegerString[] a){
        StringBuffer sb = new StringBuffer();
        int max = getMaxLength(a);
        for(int i=0;i<=max;i++){
            boolean isFind = false;
            for(int j=0;j<a.length;j++){
                if(a[j].getLength()==i){
                    sb.insert(0,a[j].getNumber());
                    isFind = true;
                    break;
                }
            }
            if(!isFind){
                sb.insert(0,0);
            }
        }
        return sb.toString();
    }

    //两个数相加
    private IntegerString[] add(IntegerString[] a,IntegerString[] b){
        if(a==null) return b;
        if(b==null) return a;
       java.util.ArrayList arrays = new java.util.ArrayList();
       int aMax = getMaxLength(a);
       int bMax = getMaxLength(b);
       int max = aMax>bMax?aMax:bMax;
       int carry = 0;
       for(int i=0;i<=max;i++){
           
            for(int j1=0;j1<a.length;j1++){
                if(a[j1].getLength()==i)
                    carry+=a[j1].getNumber();
            }
            for(int j2=0;j2<b.length;j2++){
                 if(b[j2].getLength()==i)
                    carry+=b[j2].getNumber();
            }
            if(carry>0){
                if(carry>=10){
                    arrays.add(new IntegerString(carry%10,i));
                    carry=1;
                    if(i==max){
                        arrays.add(new IntegerString(carry,i+1));
                    }
                }else{
                    arrays.add(new IntegerString(carry,i));
                    carry=0;
                }
            }else{
                arrays.add(new IntegerString(0,i));
                carry=0;
            }
       }
       IntegerString[] results = new IntegerString[arrays.size()];
       java.util.Iterator ii = arrays.iterator();
       int index=0;
       while(ii.hasNext()){
           results[index++] = (IntegerString)ii.next();
       }
       return results;
    }

     //两个数相乘

     private String stringMultiply(String a,String b){
        IntegerString[] ais = this.getIntegerString(a);
        IntegerString[] bis = this.getIntegerString(b);
        IntegerString[] result = null;
        for(int i=0;i<bis.length;i++){
            IntegerString[] tmp = this.singleMultiply(ais,bis[i]);
            result = add(result,tmp);
        }
        return this.getNumberic(result);
    }

    //打印N的阶乘

    public void printFactorial(int n){

        String total = "1";
        int n=100;
        for(int i=1;i<=n;i++){
            total = stringMultiply(i+"",total);
        }

        System.out.println(total);

    }

}

使用此类计算的100的阶乘位：

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000


此类也可以作为两个任意数字相乘，而且不会一越界。

以上算法可能存在的问题就是：

1）字符数组是以int位最大范围，可能超出界限，改进的方法是使用动态数组ArrayList

2)涉及到的算法含有大量的字符串操作，速度不是很快，当n=1000时，需要花费大量的时间，这点需要改进

3）如果N非常大，可能会造成内存不足的情况。