C++常用递归函数汇总

生活中我们总会遇到一些用递归的情况，但有很多时候都是常见的 gcd 、lcm 等，这样就可以把它们背下来。本文为大家作一个参考，以后可以用到。

最大公约数 gcd

最大公因数，也称最大公约数、最大公因子，指两个或多个整数共有约数中最大的一个。a，b的最大公约数记为 $(a,b)$ ，同样的，a，b，c的最大公约数记为 $(a,b,c)$ ，多个整数的最大公约数也有同样的记号。求最大公约数有多种方法，常见的有质因数分解法、短除法、辗转相除法、更相减损法。与最大公约数相对应的概念是最小公倍数，a，b的最小公倍数记为 $[a,b]$ 。

求最大公约数时，我们可以考虑一种使用辗转相除（欧几里得算法）的方法来计算。

int gcd(int x, int y) 
{ 
    while (y != 0) 
    { 
        int temp = y; 
        y = x % y; 
        x = temp; 
    }
    return x; 
}
1
2
3
4
5
6
7
8
9
10

也可以用更相减损术（不推荐，耗时长）：

int gcd(int x, int y)
{
    while (x != y)
    {
        if (x > y) x -= y;
        else y -= x;
    }
    return a;
}
1
2
3
4
5
6
7
8
9

注：
更相减损术是出自《九章算术》的一种求最大公约数的算法，它原本是为约分而设计的，但它适用于任何需要求最大公约数的场合。
步骤：
第一步：任意给定两个正整数；判断它们是否都是偶数。若是，则用2约简；若不是则执行第二步。
第二步：以较大的数减较小的数，接着把所得的差与较小的数比较，并以大数减小数。继续这个操作，直到所得的减数和差相等为止。
则第一步中约掉的若干个2的积与第二步中等数的乘积就是所求的最大公约数。
其中所说的“等数”，就是公约数。求“等数”的办法是“更相减损”法。

标准的递归做法（一）：

int gcd(int x, int y)
{
	if (x == y) return x;
	else if (x > y) x -= y;
	else y -= x;
	return gcd(x, y);
}
1
2
3
4
5
6
7

标准的递归做法（二）：

int gcd(int x, int y)
{
    if (x % y == 0) return y;
    else return gcd(y, x % y);
}
1
2
3
4
5

标准的递归做法（三）：

int gcd(int x, int y)
{
    return y == 0 ? x : gcd(y, x % y);
}
1
2
3
4

求多个数的最大公约数的程序案例：

#include 
using namespace std;

int gcd(int a, int b)
{
	if (a % b == 0) return b;
	else return gcd(b, a % b);
}

int main()
{
	int a[8] = {32, 16, 12, 24, 36, 20, 40, 28}; //最大公约数：4
	int L = sizeof(a) / sizeof(int);        //L为元素个数
	int m = a[0];	//初始化最大公约数：a[0]
	for (int i = 1; i < L; i++)	//从a[1]开始
	{		
		m = gcd(m, a[i]);
	}
	cout << m << endl;	//输出最大公约数：4
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

上面的算法比较慢，所以可以优化一下：

#include 
#include 
using namespace std;

bool cmp(int a, int b)	//cmp函数，确定sort函数排序的规则
{    
    return a > b;
}

int gcd(int num[], int n)   //求多个数的最大公约数的算法
{
    sort(num, num + n, cmp);
    while (num[0] != num[n - 1])
    {
        for (int i = 0; i < n - 1; i++)
        {
            if (num[i] % num[i + 1] == 0)
                num[i] = num[i + 1];
            else
                num[i] = num[i] % num[i + 1];
        }
        sort(num, num + n, cmp);
    }
    return num[0];
}

int main()
{
    int a[8] = { 32,16,12,24,36,20,40,28 }; //最大公约数：4
    int L = sizeof(a) / sizeof(int);        //L为元素个数
    cout << gcd(a, L);      				//输出最大公约数：4
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

最小公倍数 lcm

两个或多个整数公有的倍数叫做它们的公倍数，其中除0以外最小的一个公倍数就叫做这几个整数的最小公倍数。整数a，b的最小公倍数记为 $[a,b]$ ，同样的，a，b，c的最小公倍数记为 $[a,b,c]$ ，多个整数的最小公倍数也有同样的记号。
与最小公倍数相对应的概念是最大公约数，a，b的最大公约数记为 $(a,b)$ 。关于最小公倍数与最大公约数，我们有这样的定理：$(a,b)x[a,b]=ab$（a，b均为整数）。

需要与 gcd 搭配使用。

int lcm(int a, int b)
{
	int temp = a * b;
	temp = temp / gcd(a, b); //需要把gcd函数也写上
	return temp;
}
1
2
3
4
5
6

求多个数的最小公倍数：

#include 
using namespace std;

int gcd(int a, int b)
{
	if (a % b == 0) return b;
	else return gcd(b, a % b);
}

int lcm(int a, int b)
{
	int temp = a * b;
	temp = temp / gcd(a, b);
	return temp;
}

int main()
{
	int a[4] = {40, 20, 10, 30};			//最小公倍数：120
	int L = sizeof(a) / sizeof(int);	//L为元素个数
	int m = a[0];	//初始化最小公倍数：a[0]
	for (int i = 1; i < L; i++)	//从 a[1]开始
	{		
		m = m * a[i] / gcd(m, a[i]);
	}
	cout << m;      				//输出最小公倍数：120
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

斐波那契 fibonacci

斐波那契数列（Fibonacci sequence），又称黄金分割数列，因数学家莱昂纳多·斐波那契（Leonardo Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34…… 在数学上，斐波那契数列以如下被以递推的方法定义：$F(0)=0，F(1)=1,F(n)=F(n-1)+F(n-2)$ $(n\ge 2，n\in N\ast )$ 在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用，为此，美国数学会从 1963 年起出版了以《斐波纳契数列季刊》为名的一份数学杂志，用于专门刊载这方面的研究成果。

求斐波那契数列的第 x 项的函数。

int fibonacci(int x)
{
	if (x == 1 || x == 2) return 1;
	return fibonacci(x - 1) + fibonacci(x - 2);
}
1
2
3
4
5

组合数 cmb

从 $n$ 个不同元素中，任取 $m(m\le n)$ 个元素并成一组，叫做从 $n$ 个不同元素中取出m个元素的一个组合；从 $n$ 个不同元素中取出 $m(m\le n)$ 个元素的所有组合的个数，叫做从 $n$ 个不同元素中取出 $m$ 个元素的组合数。

int cmb(int x, int y)
{
	int sum = 0;
	if (x == y || y == 0)
		return 1;
	else
		return cmb(x - 1, y) + cmb(x - 1, y - 1);
}
1
2
3
4
5
6
7
8

本文完。整理不易，希望大家支持。