C++ ！！史上最全！！ 大数阶乘N！

C++ 大数阶乘N！

在刷题的时候被小小的阶乘卡住了，记录一下自己走的弯路吧 ！

一、最简单的小数阶乘

我们知道 int 的取值范围是 -2147183648 ~ +2147183648（即-2³¹~+(2³¹-1)），大致范围为-2×10⁹ ~2×10⁹ ，则用int最多只能存放 12！= 479001600（13！= 6227020800）。
而 long long的取值范围是 -2⁶³~+(2⁶³-1)），大致范围为-9×10¹⁸ ~ 9×10¹⁸ ，则用int最多只能存放 20！= 2432902008176640000（21！= 51090942171709440000）。
实现小数阶乘的方法有以下几种：

1. 暴力法

该程序在每次输入n时，都会调用Fac()来暴力计算以得到结果。

//************ 小数阶乘---暴力法 ****************
#include<iostream>  
using namespace std;  
  
int Fac(int n)  
{  
    int facResult = 1;
    for (int i = 1; i <= n; i++)
    {
        facResult *= i;
    }  
    return facResult;  
}  
  
int main()  
{  
    int n;  
    while (cin>>n)  
    {  
        cout<<n<<"!= "<<Fac(n)<<::endl;  
    }  
    return 0;  
}  

2. 数组记录法

用数组记录已经计算得到的结果，避免重复计算，节省了时间但是消耗了内存。

//************ 小数阶乘---数组记录法 ****************

#include<iostream>  
#include<vector>
using namespace std;  
vector<int> facVec(2,1);  
int Fac(int n)  
{  
    while(n >= facVec.size())
    {
		facVec.push_back(facVec.back() * facVec.size());
    }  
    return facVec[n];  
}  

int main()
...
  

3. 静态变量法

用静态变量保存已经计算得到的结果，节省计算时间，也节省了内存，但是在顺序输入或者只计算一次的情况下会比较节省时间，如果随机无限次计算阶乘的话，数组记录法更快。

//************ 小数阶乘---静态变量法 ****************

#include<iostream>  
#include<vector>
using namespace std;  

int Fac(int n)  
{  
	if (n == 0 || n == 1){
		return 1;
	}
	static int facRes = 1; //用于记录计算结果
	static int facCnt = 1; //用于记录阶乘变量
    while(n > facCnt)
    {
		facRes *= (++facCnt);
    }  
    return facRes;  
}  
  
int main()  
...
  

4. 递归法

看起来最简洁的办法，可以将上面两种方法结合进来

//************ 小数阶乘---静态变量法 ****************

#include<iostream>  
using namespace std;  

int Fac(int n)  
{  
	if (n == 0 || n == 1){
		return 1;
	} else {
		return Fac(n-1) * n;
	}
}  
  
int main()  
...
 

以上全都是用来计算小数阶乘的办法，如果超出范围，会发成错误，实验结果如下：

阶乘结果定义为int型时，在计算 13！ 时发生错误；

阶乘结果定义为long long型时，在计算 21！ 时发生错误；

二、大数阶乘

在计算20！以上的数值，就不能使用以上方法了，就需要考虑其他存放数据的方法，我们常用的存放大数的方法有 使用字符串存储和使用数值存储。

1. 使用字符串存储

1.1. 字符串存储初级版

#include<iostream>
#include<string>
using namespace std;
string Mutiple(string num1, int num2)
{
    string res;
    int c = 0;
    for (int i = num1.size() - 1; i >= 0; i--){
        int tmp = (num1[i]-'0') * num2 + c;
        c = tmp / 10; // 记录进位
        tmp = tmp % 10; 
        res.insert(res.begin(), tmp+'0'); // 插入当前位计算结果
    }
    while (c){ // 插入剩余进位
        int tmp = c % 10;
        c = c / 10;
        res.insert(res.begin(),tmp+'0');
    }
    return res;
}

string Fac(int n)   // 递归函数
{
	if (n == 0 || n == 1){
		return "1";
	} else {
		return Mutiple(Fac(n - 1), n);
	}
}

int main(){
    int n;
    while (cin>>n)
    {
         cout<<Fac(n)<<::endl;
    }
    return 0;
}

1.2. 字符串存储升级版

初级版使用暴力法递归计算递归结果，使用数组记录法减少重复计算。

#include<iostream>
#include<vector>
#include<string>
using namespace std;
vector<string> nVec(2,"1");
string Mutiple(string num1, int num2){
    ...
}

string Fac(int x)   //递归函数
{
	if(x >= nVec.size()){
		nVec.push_back(Mutiple(Fac(x - 1), x));
	}
	return nVec[x];
}
int main(){
  ...
}

但是依然没有达到要求的运算速度，考虑之后发现，使用字符串存储大数会花费很多时间在类型转换上，这些过程十分的耗时，于是考虑使用数组存放大数。

2. 使用数组存储

2.1 数组存储初级版

#include<iostream>
#include<vector>
using namespace std;
vector<vector<int>> nVec(2,vector<int>(1,1));
void mutiple(vector<int> num1, int num2){

    vector<int> res;
    int c = 0;
	for (auto i = num1.begin(); i != num1.end(); i++){
        int tmp = *i * num2 + c;
        c = tmp / 10;
        tmp = tmp % 10;
        res.push_back(tmp);
    }
    while (c){
        res.push_back(c % 10);
		c /= 10;
    }
	nVec.push_back(res);
}
void coutVec(vector<int> numPlus) // 倒序输出
{
	for(int i = numPlus.size() - 1; i >= 0; i--)
	{
		cout<<numPlus[i];
	}
	cout<<::endl;
}
vector<int> fac(int x)   
{
	while(x >= nVec.size()){
		mutiple(nVec.back(), nVec.size());
	}
	return nVec[x];
}
int main(){
    int n;
    while (cin>>n)
    {
         coutVec(fac(n));
    }
    return 0;
}

2.2 数组存储升级版

初级版终于满足了运行时间的要求，但是运行内存不达标。观察发现，并不需要将计算的所有结果都进行存储，只需要保留最后的计算结果就可以了。

#include<iostream>
#include<vector>
using namespace std;
vector<int> nVec(1,1);
int lastN = 1;
void Mutiple(vector<int> num1, int num2)
{
    vector<int> res;
    int c = 0;
	for (auto i = num1.begin(); i != num1.end(); i++){
        int tmp = *i * num2 + c;
        c = tmp / 10;
        tmp = tmp % 10;
        res.push_back(tmp);
    }
    while (c){
        res.push_back(c % 10);
		c /= 10;
    }
	nVec = res;
}
void CoutVec(vector<int> numPlus)
{
	for(int i = numPlus.size() - 1; i >= 0; i--)
	{
		cout<<numPlus[i];
	}cout<<::endl;
}
vector<int> fac(int x)   
{
	if(x == 0 || x == 1){
		return vector<int>(1,1);
	}
	while(x > lastN){
		Mutiple(nVec, ++lastN);
	}
	return nVec;
}
int main(){
    int n;
    while (cin>>n)
    {
         CoutVec(fac(n));
    }
    return 0;
}

终于达到预期要求，完结撒花。

有更好的方法欢迎评论啊！！！