面试题：如何求最大公约数

题目

写一段代码，求出两个整数的最大公约数，要尽量优化算法的性能。

实现方法一

这种方式性能不是非常好

package arithmetic.com.ty.binary;

public class SimpleGreatestCommon {

    public static int getGreatestCommonDivisor(int a, int b) {
        int big = a > b ? a : b;
        int small = a < b ? a : b;
        if (big % small == 0) {
            return small;
        }
        for (int i = small / 2; i > 1; i--) {
            if (small % i == 0 && big % i == 0) {
                return i;
            }
        }
        return 1;
    }

    public static void main(String[] args) {
        System.out.println(getGreatestCommonDivisor(25, 5));
        System.out.println(getGreatestCommonDivisor(100, 80));
        System.out.println(getGreatestCommonDivisor(27, 14));
    }
}

思路：对于两个数a、b，假设a>b，则从b/2开始循环(基本的数学知识)，求出二者的最大公约数。

不过这个方法效率偏低，例如对于10000、10001两个数，需要循环4999次。

实现方法二

欧几里得算法：又叫辗转相除法。这条算法基于一个定理：两个正整数a和b（a>b），它们的最大公约数等于a除以b的余数c和b之间的最大公约数。例如10和25，25除以10商2余5，那么10和25的最大公约数，等同于10和5的最大公约数。

首先，计算出a除以b的余数c，把问题转化成求b和c的最大公约数；然后计算出b除以c的余数d，把问题转化成求c和d的最大公约数；再计算出c除以d的余数e，把问题转化成求d和e的最大公约数……以此类推，逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，直到两个数可以整除，或者其中一个数减小到1为止。

package arithmetic.com.ty.binary;

public class GreatestCommonDivisor {
    public static int getGreatestCommonDivisorV2(int a, int b) {
        int big = a > b ? a : b;
        int small = a < b ? a : b;
        if (big % small == 0) {
            return small;
        }
        return getGreatestCommonDivisorV2(big % small, small);
    }

    public static void main(String[] args) {
        System.out.println(getGreatestCommonDivisorV2(25, 5));
        System.out.println(getGreatestCommonDivisorV2(100, 80));
        System.out.println(getGreatestCommonDivisorV2(27, 14));
    }
}

缺点：big%small在数值比较大的时候，性能较差。

实现方法三

更相减损术：两个正整数a和b（a>b），它们的最大公约数等于a-b的差值c和较小数b的最大公约数。例如10和25，25减10的差是15，那么10和25的最大公约数，等同于10和15的最大公约数。

由此，我们同样可以通过递归来简化问题。首先，计算出a和b的差值c（假设a>b），把问题转化成求b和c的最大公约数；然后计算出c和b的差值d（假设c>b），把问题转化成求b和d的最大公约数；再计算出b和d的差值e（假设b>d），把问题转化成求d和e的最大公约数……

package arithmetic.com.ty.binary;

public class GreatestCommonDivisor {
    public static int getGreatestCommonDivisorV3(int a, int b) {
        if (a == b) {
            return a;
        }
        int big = a > b ? a : b;
        int small = a < b ? a : b;
        return getGreatestCommonDivisorV3(big - small, small);
    }

    public static void main(String[] args) {
        System.out.println(getGreatestCommonDivisorV3(25, 5));
        System.out.println(getGreatestCommonDivisorV3(100, 80));
        System.out.println(getGreatestCommonDivisorV3(27, 14));
    }
}

缺点：但是，更相减损术依靠两数求差的方式来递归，运算次数肯定远大于辗转相除法的取模方式

实现方法四-----最优方法

把辗转相除法和更相减损术的优势结合起来，在更相减损术的基础上使用移位运算。

下面将getGreatestCommonDivisor简写为gcd，实现思想如下：

当a和b均为偶数时，gcd(a,b) = 2×gcd(a/2, b/2) = 2×gcd(a>>1,b>>1)。

当a为偶数，b为奇数时，gcd(a,b) = gcd(a/2,b) = gcd(a>>1,b)。

当a为奇数，b为偶数时，gcd(a,b) = gcd(a,b/2) = gcd(a,b>>1)。

当a和b均为奇数时，先利用更相减损术运算一次，gcd(a,b)=gcd(b,a-b)，此时a-b必然是偶数，然后又可以继续进行移位运算。

 

例如：计算10和25的最大公约数的步骤如下。

1. 整数10通过移位，可以转换成求5和25的最大公约数。

2.利用更相减损术，计算出25-5=20，转换成求5和20的最大公约数。

3. 整数20通过移位，可以转换成求5和10的最大公约数。

4. 整数10通过移位，可以转换成求5和5的最大公约数。

5. 利用更相减损术，因为两数相等，所以最大公约数是5。

这种方式在两数都比较小时，可能看不出计算次数的优势；当两数越大时，计算次数的减少就会越明显。

代码如下：

package arithmetic.com.ty.binary;

public class Gcd {
    public static int gcd(int a, int b) {
        if (a == b) {
            return a;
        }
        //如果a、b都是偶数
        if ((a & 1) == 0 && (b & 1) == 0) {
            return gcd(a >> 1, b >> 1) << 1;
        } 
        //a是偶数，b是奇数
        else if ((a & 1) == 0 && (b & 1) != 0) {
            return gcd(a >> 1, b);
        } 
        //a是奇数，b是偶数
        else if ((a & 1) != 0 && (b & 1) == 0) {
            return gcd(a, b >> 1);
        } else {
            int big = a > b ? a : b;
            int small = a < b ? a : b;
            return gcd(big - small, small);
        }
    }

    public static void main(String[] args) {
        System.out.println(gcd(25, 5));
        System.out.println(gcd(100, 80));
        System.out.println(gcd(27, 14));
    }
}