5.4.1 一场求最大公约数的面试
下面我来考查你一道算法题，数学里面的最大公约数，知道吧？
这个我知道，小学就学过。
那么，看看下面这个算法题。
题目
写一段代码，求出两个整数的最大公约数，要尽量优化算法的性能。
哦，让我试试……
写出来啦！你看看。
小灰的代码如下：
1. public static int getGreatestCommonDivisor(int a, int b){
2. int big = a>b ? a:b;
3. int small = a
4. if(big%small == 0){
5. return small;
6. }
7. for(int i= small/2; i>1; i--){
8. if(small%i==0 && big%i==0){
9. return i;
10. }
11. }
12. return 1;
13. }
14.
15. public static void main(String[] args) {
16. System.out.println(getGreatestCommonDivisor(25, 5));
17. System.out.println(getGreatestCommonDivisor(100, 80));
18. System.out.println(getGreatestCommonDivisor(27, 14));
19. }
小灰的思路十分简单。他使用暴力枚举的方法，从较小整数的一半开始，试图找到一个合适的整数i，看看这个整数能否被a和b同时整除。
你这个方法虽然实现了所要求的功能，但是效率不行啊。想想看，如果我传入的整数是10 000和10 001，用你的方法就需要循环10 000/2-1=4999次！
哎呀，这倒是个问题。
想不出更好的方法了……
呵呵，没关系，回家等通知去吧！
5.4.2 解题思路
小灰，你刚刚去面试了？结果怎么样？
唉……
大黄，怎么才能更高效地求出两个整数的最大公约数呀？
小灰，你听说过辗转相除法 吗？
辗……什么除法？
是辗转相除法！又叫作欧几里得算法。
辗转相除法， 又名欧几里得算法（Euclidean algorithm），该算法的目的是求出两个正整数的最大公约数。它是已知最古老的算法， 其产生时间可追溯至公元前300年前。
这条算法基于一个定理：两个正整数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为止。
说了这么多理论不如直接写代码，小灰，你按照辗转相除法的思路改改你的代码吧。
好的，让我试试！
辗转相除法的实现代码如下：
1. public static int getGreatestCommonDivisorV2(int a, int b){
2. int big = a>b ? a:b;
3. int small = a
4. if(big%small == 0){
5. return small;
6. }
7. return getGreatestCommonDivisorV2(big%small, small);
8. }
9.
10. public static void main(String[] args) {
11. System.out.println(getGreatestCommonDivisorV2(25, 5));
12. System.out.println(getGreatestCommonDivisorV2(100, 80));
13. System.out.println(getGreatestCommonDivisorV2(27, 14));
14. }
没错，这确实是辗转相除法的思路。不过有一个问题，当两个整数较大时，做a%b取模运算的性能会比较差。
这我也明白，可是不取模的话，还能怎么办呢？
说到这里，另一个算法就要登场了，它叫作更相减损术 。
更相减损术，出自中国古代的《九章算术》，也是一种求最大公约数的算法。古希腊人很聪明，可是我们炎黄子孙也不差。
它的原理更加简单：两个正整数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的最大公约数……
以此类推，逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，直到两个数可以相等为止，最大公约数就是最终相等的这两个数的值。
OK，这就是更相减损术的思路，你按照这个思路再写一段代码看看。
好的，让我试试！
更相减损术的实现代码如下：
1. public static int getGreatestCommonDivisorV3(int a, int b){
2. if(a == b){
3. return a;
4. }
5. int big = a>b ? a:b;
6. int small = a
7. return getGreatestCommonDivisorV3(big-small, small);
8. }
9.
10. public static void main(String[] args) {
11. System.out.println(getGreatestCommonDivisorV3(25, 5));
12. System.out.println(getGreatestCommonDivisorV3(100, 80));
13. System.out.println(getGreatestCommonDivisorV3(27, 14));
14. }
很好，更相减损术的过程就是这样。我们避免了大整数取模可能出现的性能问题，已经越来越接近最优解决方案了。
但是，更相减损术依靠两数求差的方式来递归，运算次数肯定远大于辗转相除法的取模方式吧？
能发现问题，看来你进步了。更相减损术是不稳定的算法，当两数相差悬殊时，如计算10000和1的最大公约数，就要递归9999次！
有什么办法可以既避免大整数取模，又能尽可能地减少运算次数呢？
下面就是我要说的最优方法：把辗转相除法和更相减损术的优势结合起来，在更相减损术的基础上使用移位运算。
众所周知，移位运算的性能非常好。对于给出的正整数a和b，不难得到如下的结论。
（从下文开始，获得最大公约数的方法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。
这种方式在两数都比较小时，可能看不出计算次数的优势；当两数越大时，计算次数的减少就会越明显。
说了这么多，来看看代码吧，这是最终版本的代码。
1. public static int gcd(int a, int b){
2. if(a == b){
3. return a;
4. }
5. if((a&1)==0 && (b&1)==0){
6. return gcd(a>>1, b>>1)<<1;
7. } else if((a&1)==0 && (b&1)!=0){
8. return gcd(a>>1, b);
9. } else if((a&1)!=0 && (b&1)==0){
10. return gcd(a, b>>1);
11. } else {
12. int big = a>b ? a:b;
13. int small = a
14. return gcd(big-small, small);
15. }
16. }
17.
18. public static void main(String[] args) {
19. System.out.println(gcd(25, 5));
20. System.out.println(gcd(100, 80));
21. System.out.println(gcd(27, 14));
22. }
在上述代码中，判断整数奇偶性的方式是让整数和1进行与运算，如果(a&1)==0，则说明整数a是偶数；如果(a&1)!=0，则说明整数a是奇数。
真不容易呀，终于得到了最优解！
嘿嘿，作为程序员，就是需要反复推敲，追求代码的极致！
我还有最后一个问题，咱们使用的这些方法，时间复杂度分别是多少呢？
让我们来总结一下上述解法的时间复杂度。
1. 暴力枚举法： 时间复杂度是O(min(a, b))。
2. 辗转相除法： 时间复杂度不太好计算，可以近似为O(log(max(a, b)))，但是取模运算性能较差。
3. 更相减损术： 避免了取模运算，但是算法性能不稳定，最坏时间复杂度为O(max(a, b))。
4. 更相减损术与移位相结合： 不但避免了取模运算，而且算法性能稳定，时间复杂度为O(log(max(a, b)))。
好了，有关最大公约数的求解，我们就介绍到这里。咱们下一节再会！