求最大公约数

(1)暴力枚举法

暴力枚举法很简单,从较小整数的一班开始,试图找到一个合适的整数i,检查这个整数i是否被a和b同时整除;

 /**
     * 暴力枚举法求最大公约数
     *
     * @param a
     * @param b
     * @return
     */
    public static int getGreatestCommonDivisor_v1(int a, int b) {
        int bigger = a > b ? a : b;
        int smaller = a < b ? a : b;
        if (bigger % smaller == 0) {
            return smaller ;
        }
        for (int i = smaller / 2; i > 1; i--) {
            if (smaller%i==0 && bigger%i==0){
                return i;
            }
        }
        return 1;
    }

注意:这个方法简单暴力的实现了功能,但是效率不行,想想,如果传入的整数是100001和10000,使用上述方法需要循环10000/2-1=4999次!效率太低,我们看看更高效点的方法——辗转相除法。

(2)辗转相除法

辗转相除法，又称欧几里得算法，该算法的目的是求出两个正整数的最大公约数。

算法定理：两个正整数a和b(a>b),他们的最大公约数等于a除以b的余数c和b之间的最大公约数.

例如10和25,25除以10商2余5,那么10和25的最大公约数等同与10和5的最大公约数,以此类推,逐渐把两个较大的整数之间的运算简化成两个较小整数之间的运算,直到两个数据可以整除,或着其中一个整数小到1为止.根据定理描述,我们可以使用递归的方法把问题逐步简化.

 /**
     * 辗转相除法求最大公约数
     *
     * @param a
     * @param b
     * @return
     */
    public static int getGreatestCommonDivisor_v2(int a, int b) {
        int bigger = a > b ? a : b;
        int smaller = a < b ? a : b;
        if (bigger % smaller == 0) {
            return smaller;
        }
        return getGreatestCommonDivisor_v2(bigger % smaller, smaller);
    }

注意:当两个整数较大时,做a%b取模运算的性能会比较差,我们试试看能不能不取模,试试《九章算术》——更相减损术

(3)更相减损术

原理：两个正整数a和b(a>b),他们的最大公约数等于a-b的差值c和较小数b的最大公约数

由此,我们同样使用递归的方式来简化问题.首先,计算出a和b的差值c(假设a>b),把问题转化成求c和b的最大公约数;然后计算出c和b的差值d(假设c>b),把问题转化成求d和b的最大公约数,就这样一致转化下去.......逐渐把两个较大的整数之间的运算简化成两个较小整数之间的运算,直到两个数可以相等为止,最大公约数就是最终相等的这两个数的值.

/**
     * 使用更相减损术求最大公约数
     * @param a
     * @param b
     * @return
     */
    public static int getGreatestCommonDivisor_v3(int a, int b) {
        if (a == b ) {
            return a;
        }
        int bigger = a > b ? a : b;
        int smaller = a < b ? a : b;
        return getGreatestCommonDivisor_v3(bigger-smaller,smaller) ;
    }

注意:更相减损术根据两数之差的方式递归,运算次数肯定远大于辗转相除法.更相减损术是不稳定的算法,当两数相差悬殊时,如计算100000和1的最大公约数,就要递归99999次!什么方法可以避免取模运算又能尽量减少运算次数呢,我们可以试试下面这个方法.

(4)更相减损术与位移相结合

优点:把辗转相除法和更相减损术的优势相结合,在更相减损术的基础上使用位移运算.

当a和b均为偶数时,getGreatestCommonDivisor_v4(a,b)=2*getGreatestCommonDivisor_v4(a/2,b/2)=2*getGreatestCommonDivisor_v4(a>>1,b>>1);

当a为偶数,b为奇数时,getGreatestCommonDivisor_v4(a,b)=getGreatestCommonDivisor_v4(a/2,b)=getGreatestCommonDivisor_v4(a>>1,b);

当a为奇数,b为偶数时,getGreatestCommonDivisor_v4(a,b)=getGreatestCommonDivisor_v4(a,b/2)=getGreatestCommonDivisor_v4(a,b>>1);

当a,b均为奇数时,先利用更相减损术运算一次,getGreatestCommonDivisor_v4(a,b)=getGreatestCommonDivisor_v4(b,a-b),此时a-b必然是偶数,然后有可以继续位移运算了.

 /**
     * 更相减损术与位移相结合
     * @param a
     * @param b
     * @return
     */
    public static int getGreatestCommonDivisor_v4(int a, int b) {
        if (a==b){
            return a;
        }
        if((a&1)==0 && (b&1)==0){
            return getGreatestCommonDivisor_v4(a>>1,b>>1)<<1;
        }else if((a&1)==0 && (b&1)!=0){
            return getGreatestCommonDivisor_v4(a>>1,b);
        }else if((a&1)!=0 && (b&1)==0){
            return getGreatestCommonDivisor_v4(a,b>>1);
        }else {
            int bigger = a > b ? a : b;
            int smaller = a < b ? a : b;
            return getGreatestCommonDivisor_v4(bigger-smaller,smaller);
        }
    }

1.暴力枚举法:时间复杂度为O(min(a,b));

2.辗转相除法:时间复杂度不好计算,可以近似为O(log(max(a,b))),但是取模运算性能较差;

3.更相减损术:避免了取模运算,但是算法性能不稳定,最坏时间复杂度为O(max(a,b));

4.更相减损术与位移相结合:不但避免了取模运算,而且算法性能稳定,时间复杂度为O(log(max(a,b)));