如何求出最大公约数？

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

（1）暴力枚举：
从较小整数的一半开始，试图找到一个合适的整数 i，看看这个整数能否被 a 和 b 同时整除。

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));
}

虽然实现了功能，但是效率不行，如果传入的整数是10000和10001，就需要循环 10000/2 - 1 = 4999次！

（2）辗转相除法
又名欧几里得算法，该算法的目的是求出两个正整数的最大公约数。该算法基于一个定理：两个正整数 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为止。

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));
}

有一个问题，当两个整数较大时，做a%b取模运算的性能会比较差。

（3）更相减损法
原理：两个正整数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的最大公约数。。。以此类推，逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，直到两个数可以相等为止，最大公约数就是最终相等的这两个数的值。

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));
}

更相减损法是不稳定的算法，当两数相差悬殊时，如计算10000和1的最大公约数，就要递归9999次！

（4）更相减损法和移位相结合

public static int gcd(int a,int b){
    if(a == b){
        return a;
    }
    if((a&1)==0 && (b&1)==0){
        return gcd(a>>1,b>>1)<<1;
    } else if ((a & 1) == 0 && (b & 1) != 0) {
        return gcd(a>>1,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));
}