辗转相除/更相减损/移位，求最大公约数

本文总结自：《漫画算法：小灰的算法之旅》魏梦舒

public class Main{

    public static void main(String[] args){
        int a = 35;
        int b = 21;
        System.out.println(getGreatestCommonDivisor(a, b));
        System.out.println(subtract(a, b));
        System.out.println(subtractV2(a, b));
    }

    private static int getGreatestCommonDivisor(int a, int b) {
        int result;
        if (a > b) {
            result = divide(a, b);
        } else {
            result = divide(b, a);
        }
        return result;
    }

    private static int divide(int a, int b) {
        if (a % b == 0) {
            return b;
        } else {
            //辗转相除法：两个正整数a和b（a>b），它们的最大公约数等于 a除以b的余数c 和 b 之间的最大公约数
            //以此类推，逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，直到两个数可以整除，或者其中一个数减小到1为止
            //缺点：当两个整数较大时，a%b性能较低
            return divide(b, a % b);
        }
    }

    private static int subtract(int a, int b) {
        if (a == b) {
            return a;
        } else if (a > b) {
            //更相减损法：两个正整数a和b（a>b），它们的最大公约数等于 a-b的差值c 和 较小数b 的最大公约数
            //以此类推，逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，直到两个数可以相等为止，最大公约数就是最终相等的两个数
            //缺点：不稳定的算法，当两数相差悬殊时，比如计算10000和1，就要递归9999次
            return subtract(a - b, b);
        } else {
            return subtract(b - a, a);
        }
    }

    private static int subtractV2(int a, int b) {
        if (a == b) {
            return a;
        }
        //保证a > b
        if (a < b) {
            return subtractV2(b, a);
        }
        //位与运算判断奇偶
        if ((a & 1) == 0 && (b & 1) == 0) {
            //当a和b均为偶数，gcd(a,b) = 2*gcd(a/2, b/2) = 2*gcd(a>>1, b>>1)
            return subtractV2(a >> 1, b >> 1) << 1;
        } else if ((a & 1) == 0) {
            //当a为偶数，b为奇数，gcd(a,b) = gcd(a/2, b) = gcd(a>>1, b)
            return subtractV2(a >> 1, b);
        } else if ((b & 1) == 0) {
            //当a为奇数，b为偶数，gcd(a,b) = gcd(a, b/2) = gcd(a, b>>1)
            return subtractV2(b >> 1, a);
        } else {
            //当a和b均为奇数，利用更相减损法运算一次，gcd(a,b) = gcb(a - b, b)，此时a-b必然是偶数，又可以继续进行移位运算。
            return subtractV2(a - b, b);
        }
    }

}