问题：

求两个数的最大公约数

解法一：

欧几里得辗转相除法：

f(x,y) = GCD(x,y), 取k = x / y, b = x % y,则：x = k*y + b;
如果一个数能整除x,y,则它也能整除b,y； 而且能整除b,y的数必能整除x,y，即x,y和b,y的公约数是相同的，其最大公约数也是相同的，即f(x,y) = f(y ,x % y) (x>=y>0)

例如，计算a = 1071和b = 462的最大公约数的过程如下：从1071中不断减去462直到小于462（可以减2次，即商q0 = 2），余数是147：
1071 = 2 × 462 + 147.
然后从462中不断减去147直到小于147（可以减3次，即q1 = 3），余数是21：
462 = 3 × 147 + 21.
再从147中不断减去21直到小于21（可以减7次，即q2 = 7），没有余数：
147 = 7 × 21 + 0.
此时，余数是0，所以1071和462的最大公约数是21

递归算法：

[cpp]
view plain
copy

1. #include<stdio.h>
3. //递归形式
4. intGCD(inta,intb)
5. {
6. if(b==0){
7. returna;
8. }
9. else{
10. //a,b和b,a%b有相同的最大公约数
11. returnGCD(b,a%b);
12. }
14. }
16. intmain(){
17. inta,b;
18. scanf(“%d%d”,&a,&b);
19. printf(“%d\n”,GCD(a,b));
20. }

例如GCD(1071, 462)的计算过程是：

函数的第一次调用计算GCD(462, 1071 mod 462) = GCD(462, 147)；

下一次调用计算 GCD(147, 462 mod 147) = GCD(147, 21)，

在接下来是 GCD(21, 147 mod 21) = GCD(21, 0) = 21。

非递归算法：

[cpp]
view plain
copy

1. #include<stdio.h>
3. //非递归形式
4. intGCD(inta,intb)
5. {
6. inttemp=a;
7. while(b){
8. a=b;
9. b=temp%b;
10. }
11. returna;
12. }
14. intmain(){
15. inta,b;
16. scanf(“%d%d”,&a,&b);
17. printf(“%d\n”,GCD(a,b));
18. }

解法二：

在解法一中我们用到了取模运算。在大整数中取模运算（涉及到除法运算）是非常高贵的开销。

我们想想避免用取模运算。

类似前面的分析，一个数能整除x,y则必能同时整除x – y，y。能同时整除x – y,y 则必能同时整除x，y。即x,y的公约数和x-y,y的公约数是一样的，其最大公约数也是一样的。

[cpp]
view plain
copy

1. #include<stdio.h>
3. intGCD(inta,intb)
4. {
5. //如果a<b
6. if(a<b){
7. returnGCD(b,a);
8. }
9. if(b==0){
10. returna;
11. }
12. else{
13. returnGCD(a-b,b);
14. }
15. }
17. intmain(){
18. inta,b;
19. scanf(“%d%d”,&a,&b);
20. printf(“%d\n”,GCD(a,b));
21. }

此解法用减法而不是除法，这样迭代的次数比除法要多，当遇到f(10000000,1)的情况时这不是一个好方法。

解法三：

分析：

对于x,y,如果y = k * y1,x = k * x1,则f(y,x) = K*f(x1,y1)；

如果x = p * x1, 假设p是素数，且 y % p != 0 ,即y不能被p整除，则f(x,y) = f(x1,y).

可以利用上面两点进行改进。因为2是素数，同时对于二进制表示的大整数而言可以很容易的将除以2和乘以2的算法转换为移位运算，从而避免大整数除法。

可以充分利用2进行分析：
若x,y都为偶数（2肯定是公约数），则f(x,y) = 2*f(x / 2,y / 2) = 2*f(x>>1,y>>1);
若x为偶数，y为奇数(2肯定不是公约数),则f(x,y) = f(x / 2, y / 2) = f(x>>1, y)
若x为奇数，y为偶数2肯定不是公约数)，则f(x,y)= f(x, y / 2) = f(x, y>>1)
若x,y都为奇数（2肯定不是公约数），则f(x,y) = f(y, x-y) (x-y肯定为偶数) = f（y, (x-y)/2）

[cpp]
view plain
copy

1. #include<stdio.h>
2. //判断奇偶性
3. intIsEvenOdd(intn){
4. if(n%2==0){
5. return1;
6. }
7. else{
8. return0;
9. }
10. }
12. intGCD(inta,intb)
13. {
14. //如果a<b
15. if(a<b){
16. returnGCD(b,a);
17. }
18. if(b==0){
19. returna;
20. }
21. //若x,y都为偶数
22. if(IsEvenOdd(a)==1&&IsEvenOdd(b)==1){
23. return2*GCD(a>>1,b>>1);
24. }
25. //若x,y都为奇数
26. elseif(IsEvenOdd(a)==0&&IsEvenOdd(b)==0){
27. returnGCD(b,a-b);
28. }
29. //若x是偶数y是奇数
30. elseif(IsEvenOdd(a)==1&&IsEvenOdd(b)==0){
31. returnGCD(a>>1,b);
32. }
33. //若x是奇数y是偶数
34. else{
35. returnGCD(a,b>>1);
36. }
37. }
39. intmain(){
40. inta,b;
41. scanf(“%d%d”,&a,&b);
42. printf(“%d\n”,GCD(a,b));
43. }

这个算法的好处就是用移位操作来代替除法操作，大大节约时间。