数据结构---求最大公约数

写一段代码，求出两个整数的最大公约数，要尽量优化算法的性能。
例如：12和6的公约数2与3中,3是最大公约数。

穷举法

package algorithmProblem;

public class greatestCommonDivisor {
    public static int greatest(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--){
            //从较小整数的一半开始，试图
            //找到一个合适的整数i，看看这个整数能否被a和b同时整除。
            if(small%i==0&&big%i==0){
                return i;
            }
        }
        //1是任何数的公约数
        return 1;
    }

    public static void main(String[] args) {
        System.out.println(greatest(1000,1001));
    }
}

存在的问题：如果求1000和1001的最大公约数，得循环(1000/2)-1次。效率低

辗转相除法法

辗转相除法， 又名欧几里得算法（Euclidean algorithm），该算法的目的是求出两个正整数的最大公约数

两个正整数a和b（a>b），它们的最大公约数等于a除以b的余数c和b之间的最大公约数。

例如：25除以10商2余5，那么10和25的最大公约数，等同于10和5的最大公约数。

想到->递归法
流程

第一步

计算出a除以b的余数c，把问题转化成求b和c的最大公约数；

第二步

然后计算出b除以c的余数d，把问题转化成求c和d的最大公约数；再计算出c除以d的余数e，把
问题转化成求d和e的最大公约数……以此类推，

第三步

递归出口：
逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，直到两个数可以整除，或者其中一个数减小到1为止

JAVA实现

    public static int greatest2(int a,int b){
        int big = a>b? a:b;
        int small = a<b? a:b;
        if(big%small==0){
            return small;
        }
        if(big==1){
            return 1;
        }
        if(small==1){
            return 1;
        }
        return greatest2(big%small,small);

    }

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

更相减损术

两个正整数a和b（a>b），它们的最大公约数等于a-b的差值c和较小数b的最大公约数

这样就避免的取模运算…

第一步

计算出a和b的差值c（假设a>b），把问题转化成求b和c的最大公约数；

第二步

然后计算出c和b的差值d（假设c>b），把问题转化成求b和d的最大公约数；再计算出b和d的差值e（假设b>d），把问题转化成求d和e的最大公约数……以此类推，逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，

第三步

递归出口：直到两个数可以相等为止，最大公约数就是最终相等的这两个数的值。

JAVA实现

    public static int greatest3(int a,int b){
        int big = a>b? a:b;
        int small = a<b? a:b;
        if(small==big){
            return small;
        }
        if(big==1){
            return 1;
        }
        if(small==1){
            return 1;
        }
        return greatest3(big-small,small);
    }

存在的问题：更相减损术依靠两数求差的方式来递归，运算次数肯定远大于辗转相除法的取模方式

更相减损术与移位相结合

把辗转相除法和更相减损术的优势结合起来，在更相减损术的基础上使用移位运算。

操作逻辑

当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。

JAVA实现

小Tips：判断奇数偶数：待判断的数字&1看是否为0
例如 12&1 等于0
11&1==1
移位运算：>>1相当于除2，>>2相当于除4
移位运算：<<1相当于乘2，<<2相当于乘4

 /**
     * 更相减损术结合移位相结合
     *
     * @param a
     * @param b
     * @return
     */
    public static int greatest4(int a,int b){
        //递归出口
        if(a==b){
            return a;
        }

        //都是偶数的情况
        //gcd(a,b) = 2×gcd(a/2, b/2) = 2×gcd(a>>1,b>>1)
        if((a&1)==0&&(b&1)==0){
            return greatest4(a>>1,b>>1)<<1;
        }else if((a&1)==0&&(b&1)!=0){
            //当a为偶数，b为奇数时，gcd(a,b) = gcd(a/2,b) = gcd(a>>1,b)
            return greatest4(a>>1,b);
        }else if((a&1)!=0&&(b&1)==0){
//            当a为奇数，b为偶数时，gcd(a,b) = gcd(a,b/2) = gcd(a,b>>1)
            return greatest4(a,b>>1);
        }else {
//            当a和b均为奇数时，先利用更相减损术运算一次，gcd(a,b) = gcd(b,a-b)，此
//            时a-b必然是偶数，然后又可以继续进行移位运算。
            int big = a>b? a:b;
            int small = a<b? a:b;
            return greatest4(big-small,small);
        }


    }