细说算法-------最大公约数

 目录：

1、最大公约数定义、两个必记结论

2、七种算法总结比较（重点学习欧几里得算法、Stein算法）

-----------------------------------------------------------------------------------------------------------------------

定义：

最大公约数Greatest CommonDivisor(GCD)，指两个或多个整数共有约数中最大的一个。与最大公约数相对应的概念是最小公倍数，a，b的最小公倍数记为[a，b]。

结论一：

在数论中有结论：两个自然数的最大公约数与它们的最小公倍数的乘积等于这两个数的乘积，即a*b=gcd(a，b) * [a，b]，所以一般只要求得两个数的最大公约数，最小公倍数就可迎刃而解。

结论二：gcd（a,b）=gcd( b, amod b )及其扩展，详见Stein算法

如果两个数相差不大，可以用大数减去小数，所得的差与小数的最大公约数就是原来两个数的最大公约数。如果两个数相差较大，可以用大数减去小数的若干倍，一直减到差比小数小为止，差和小数的最大公约数就是原来两数的最大公约数。即：任意给定两个整数a，b，不妨假设a>=b。它们的最大公约数用gcd（a,b）表示，则gcd（a,b）=gcd( b, amod b )，其中a mod b表示a除以b所得到的余数。（欧几里得定理）

例如：求 78 和 60 的最大公约数。78－60＝18，18和60 的最大公约数是 6，所以 78 和 60 的最大公约数是 6。

例如：求 92和16的最大公约数。92－16*5＝12， 12和16的最大公约数是4，所以 92 和 16 的最大公约数就是4。

原理证明：（证明部分可以完全不看）

根据上面的假设，不妨有a=kb+r，k是整数，0<= r <|b|，则r=a mod b。设d=gcd（a,b），即a、b都可以被d整除，所以a-kb可以被d整除，因此d是b和 a mod b的公约数。

同理，假设d2是b和 a mod b（即r）的公约数，所以d2是kb+r（即a）的约数。得到d2是a和b的公约数。

综上：a和b的公约数与b和a mod b的公约数是一样的，其最大公约数也必然相等，证毕。

 

1、查找约数法。

先分别找出每个数的所有约数，再从两个数的约数中找出公有的约数，其中最大的一个就是最大公约数。缺点是程序不易实现，故不做详细介绍。

2、分解因式法。

先分别把两个数分解质因数，再找出它们全部公有的质因数，然后把这些公有质因数相乘，得到的积就是这两个数的最大公约数。例如：求 125和300 的最大公约数。因为 125＝5×5×5，300＝2×2×3×5×5，所以 125 和 300 的最大公约数是 5×5＝25。这个小学方法。实现起来效率不高，也不做代码实现。

3、短除法。

短除法求最大公约数，先用这几个数的公约数连续去除，一直除到所有的商互质为止，然后把所有的除数连乘起来，所得的积就是这几个数的最大公约数。

无论是短除法，还是分解质因数法，乘除运算过多，效率不高。因此需要寻找新方法。

短除法代码C实现如下：

#include <stdio.h>
#include <stdlib.h>

int gcd (int a ,int b) { //短除法
    int t=1;
    int i;
    for(i=2; i<=a && i<=b; i++) {
        while(a%i==0 && b%i==0) {
            t*=i;
            a/=i;
            b/=i;
        }
    }
    return t;
}

int main() {
    int a,b,c;
    printf("请输入两个数：");
    scanf("%d%d",&a,&b);
    c=gcd(a,b);
    printf("它们的最大公约数为：%d\n",c);
    return 0;
}

4、缩倍法．

如果两个数之间没有倍数关系，可以把较小的数依次除以 2、3、4……直到求得的商是较大数的约数为止，这时的商就是两个数的最大公约数．例如：求 30 和 24 的最大公约数．24÷4＝6，6 是 30 的约数，所以 30 和 24 的最大公约数是 6．

5、更相减损术。

《九章算术》是中国古代的数学专著，其中的“更相减损术”可以用来求两个数的最大公约数，方法不易用代码实现。想了解的，自行Google伪算法。

6、辗转相除法（欧几里德算法）。

当两个数都较大时，采用辗转相除法比较方便。其方法是：以大数除以小数，如果能整除，那么小数就是所求的最大公约数。否则就用余数来除刚才的除数；再用这新除法的余数去除刚才的余数。依此类推，直到一个除法能够整除，这时作为除数的数就是所求的最大公约数。

即：gcd（x,y）表示x与y的最大公约数，有gcd(x,y)=gcd（y,x%y），如此便可把原问题转化为求两个更小数的公约数，直到其中一个数为0，剩下的另外一个数就是两者的最大公约数。

例如：求 4453 和 5767 的最大公约数时，可作如下除法．

5767÷4453＝1 余 1314

4453÷1314＝3 余 511

1314÷511 ＝2  余 292

511 ÷292 ＝1  余 219

292 ÷219 ＝1  余 73

219÷73＝3      于是得知，5767 和 4453 的最大公约数是 73。辗转相除法适用比较广，比短除法要好得多，它能保证求出任意两个数的最大公约数。

辗转相除法成立的背后的数学理论，请参考另一篇博文：http://blog.csdn.net/so_geili/article/details/54970799

代码实现，如下：

//author:NWSUAF_gng
#include <iostream>
using namespace std;
int gcd (int a ,int b)//欧几里得法（辗转相除）
{
    while(b!=0)
    {
        int r=a%b;      //int r=b;
        a=b;            //b=a%b;
        b=r;            //a=r;
    }
    return a ;         //变化后的a即为最大公约数
}

int main()
{
    int a,b,c;
    cin>>a>>b;
    c=gcd(a,b);
    cout<<"最大公约数为"<<c<<endl;
    return 0;
}

gcd函数的第二种写法：

int gcd (int m,int n)
{
    int tmp;
    if(m<n)         //如果第一个比第二个数小，调换两个数
    {               //交换变量次序，完全没必要
        tmp=m;
        m=n;
        n=tmp;
    }
    while(n)
    {
        //n为较小的数，因此用n是否为0判断
        //若n为0，则较大的数m就是最大公约数
        tmp=m%n;
        m=n;
        n=tmp;
    }
    return m;
}

gcd函数的第三种写法（递归）：

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

比较辗转相除法与更相减损术的区别

都是求最大公因数的方法，计算上辗转相除法以除法为主，更相减损术以减法为主，计算次数上辗转相除法计算次数相对较少，特别当两个数字大小区别较大时计算次数的区别较明显。

7、Stein算法

欧几里德算法是计算两个数最大公约数的传统算法，无论从理论还是从实际效率上都是很好的。但是却有一个致命的缺陷，这个缺陷在素数比较小的时候一般是感觉不到的，只有在大素数时才会显现出来。

Stein算法由J. Stein1961年提出，这个方法也是计算两个数的最大公约数。和欧几里德算法算法不同的是，Stein算法只有整数的移位和加减法，这对于程序设计者是一个福音。该算法基于以下几条结论：

（1）gcd(a,0)=|a|

（2）gcd(ma,mb)=m* gcd(a,b) (分配律)

（3）gcd(a,b)=gcd(b, a mod b)

（4）gcd(a,b)=gcd(b,a-b)

（5）gcd(-a,b)=gcd(a,b)

 

Stein算法：

设置变量c用来保存a和b的最大公约数。

步骤1：初始时，令c=1.

步骤2：如果a=0，c=b*c;如果b=0，c=a*c;算法结束。

步骤3：令a1=a，b1=b；（保留初始值）

步骤4：a和b奇偶性的判断。

         如果a和b都是偶数，则a=a/2；b=b/2；c=c*2；（移位操作）

         如果a是偶数，b不是偶数，则a=a/2；（既然2不是公约数，当然可以a=a/2）

         如果b是偶数，a不是偶数，则b=b/2；

         如果a和b都不是偶数，则a=|a1 -b1|，b=min（a1，b1）；（gcd(a,b)=gcd(b,a-b)，此时a变为偶数）

转步骤2；

代码实现如下：

//author:NWSUAF_gng
#include <iostream>
#include <cmath>
using namespace std;

int gcd(int a ,int b)
{
    if(a==0) return b;
    if(b==0) return a;
    if(a%2==0 && b%2==0)
        return 2*gcd(a>>1,b>>1);
    else if(a%2==0)
        return gcd(a>>1,b);//既然2不是公约数，当然可以a=a/2
    else if(b%2==0)
        return gcd(a,b>>1);
    else
        return gcd (abs(a-b),min(a,b));//当a与b都是奇数时，利用gcd(a,b)=gcd(b,a-b)，构造偶数继续递归
int main()
{
    int a,b,c;
    cin>>a>>b;
    c=gcd(a,b);
    cout<<"最大公约数为"<<c<<endl;
    return 0;
}