面試題：如何求最大公約數

題目

寫一段代碼，求出兩個整數的最大公約數，要盡量優化算法的性能。

實現方法一

這種方式性能不是非常好

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