最大公约数和最小公倍数问题

1.问题描述

求两个数的最大公约数和最小公倍数

2.问题要求

基本要求：
1.程序风格良好(使用自定义注释模板)，两种以上算法解决最大公约数问题，提供友好的输入输出。
提高要求：
1.三种以上算法解决两个正整数最大公约数问题。
2.求3个正整数的最大公约数和最小公倍数。

3.作业提示

问题分析与算法设计

1）：求解最大公约数最常用的方法有分别列举出所有数的因数，求解最大公因数，可以使用集合的方法存储，利用集合的进行交运算求最大值
2）：辗转相除法
3）：相减法

4.问题解决

4.1程序流程图

4.2源代码

import java.util.Collections;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

/**
 * 
 * <p>
 * Title:Calculate
 * </p>
 * <p>
 * Description:该类用来计算两个数的最大公约数
 * </p>
 * 
 * @author dynamic
 * @date 2018年9月5日 下午1:11:57
 *
 */
public class Calculate {

    /**
     * 
     * @Description:该方法利用辗转相除的方法来求两数的最大公约数
     * @param a
     * @param b
     * @return max
     */

    public int cacluate1(int a, int b) {
        int max = Math.max(a, b);
        int min = Math.min(a, b);
        int temp = 0;
        boolean isStop = false;
        while (!isStop) {
            temp = max % min;
            max = Math.max(min, temp);
            min = Math.min(min, temp);
            if (temp == 0) {
                return max;

            }

        }
        return max;

    }

    /**
     * 
     * @Description:该方法利用最大公约数的性质来求解两数最大公约数, 先找出较小数的因数（由大到小依次找）并判断是否为最大数能否整除，如果可以则该数为最大公因数
     * @param a
     * @param b
     * @return（展示方法参数和返回值）
     */
    public int cacluate2(int a, int b) {
        int max = Math.max(a, b);
        int min = Math.min(a, b);
        for (int i = min; i >= 1; i--) {
            if (min % i == 0) {
                if (max % i == 0) {
                    return i;
                }
            }
        }
        return 0;

    }

    /**
     * 
     * @Description:穷举法，该方法利用利用集合的方法，先找出两个数的所有因数，然后求交集，输出交集中最大的元素
     * @param a
     * @param b
     * @return res
     */

    public int cacluate3(int a, int b) {
        Set maxSet = getFactor(Math.max(a, b));
        Set minSet = getFactor(Math.min(a, b));
        maxSet.retainAll(minSet);
        int res = (int) Collections.max(maxSet);
        ;
        return res;
    }

    /**
     * 
     * @Description: 穷举法找出每个整数的因数
     * @param temp
     * @return set
     */
    public Set getFactor(int temp) {
        Set set = new HashSet();
        for (int i = 1; i <= temp; i++) {
            if (temp % i == 0) {
                set.add(i);
            }
        }
        return set;

    }

    /**
     * 
     * @Description:该方法利用相减法求解最大公约数
     * @param a
     * @param b
     * @return a
     */
public int cacluate4(int a, int b) {
        while (a != b) {
            if (a > b) {
                a = a - b;
            } else
                b = b - a;
        }
        return a;
    }

    public static void main(String[] args) {
        System.out.println("请输入第一个正整数");
        Scanner s = new Scanner(System.in);
        int a = s.nextInt();
        System.out.println("请输入第二个正整数");
        int b = s.nextInt();
        Calculate c = new Calculate();
        System.out.println("算法一的结果" + c.cacluate1(a, b));
        System.out.println("算法二的结果" + c.cacluate2(a, b));
        System.out.println("算法三的结果" + c.cacluate3(a, b));
        System.out.println("算法四的结果" + c.cacluate3(a, b));
    }
}

三个数的最大公因数求解，核心算法与两个数最大公因数求解相同。先挑选两个数求解最大公因数，在将结果与第三个数进行最大公因数求解即可。
最小公倍数的求解可以通过两数的乘积等于最小公倍数与最大公因数的关系来求解。
具体实现代码如下：（只是简单的调用）

import java.util.Scanner;
/**
 * 
 *<p>Title:Calculates</p>
 *<p>Description:该类用来实现3个数的最大公约数与最小公倍数</p>
 * @author dynamic
 * @date 2018年9月5日 下午10:17:21
 *
 */
public class Calculates {

    private Calculate ca=new Calculate();//创建一个求解两个数的最大公约数的类的对象

    /**
     * 
     * @Description:利用辗转相除的方法求解3个数的最大公约数
     * @param a
     * @param b
     * @param c
     * @return res
     */
    public int calculate1(int a,int b,int c) {
        int res=ca.cacluate1(a, b);
         res=ca.cacluate1(res, c);
         return res;
    }
    /**
     * 
     * @Description:）利用最大公约数的定义求解3个数的最大公约数，
     *  先得出两个数的最大公约数，将其结果作为参数与第三个数求两个数的最大公约数，结果即为三个数的最大公约数
     * @param a
     * @param b
     * @param c
     * @return（展示方法参数和返回值）
     */
    public int caculate2(int a,int b, int c){

        int res=ca.cacluate2(a, b);
         res=ca.cacluate2(res, c);
        return res;

    }
    /**
     * 
     * @Description:该方法利用java集合操作，求解3个数的最大公约数 
     *  先得出两个数的最大公约数，将其结果作为参数与第三个数求两个数的最大公约数，结果即为三个数的最大公约数
     * @param a
     * @param b
     * @param c
     * @return（展示方法参数和返回值）
     */
    public int caculate3(int a,int b,int c){
        int res=ca.cacluate3(a, b);
        res=ca.cacluate3(res, c);
        return res;

    }
    /**
     * 
     * @Description:该方法用于计算3个数的最小公倍数，利用辗转相除的方法
     * 根据最小公倍数的与最大公约数的关系，先利用辗转相除的方法求解任意两个数的最小公约数，进而得到这两个数的最小公倍数，
     * 然后将结果与第三个进行最大公约数的求解，进而得到其最小公倍数，这个结果即为3个数的最小公倍数 
     * @param a
     * @param b
     * @param c
     * @return finalRes
     */
    public int caculate4(int a,int b,int c){
        int res=ca.cacluate1(a, b);
        res=a*b/res;
        int finalRes=ca.cacluate1(c, res);
        finalRes=c*res/finalRes;
        return finalRes;    
    }
    /**
     * 
     * @Description:该方法用于计算3个数的最小公倍数，根据数学定义的方法
     * 根据最小公倍数的与最大公约数的关系，先利用辗转相除的方法求解任意两个数的最小公约数，进而得到这两个数的最小公倍数，
     * 然后将结果与第三个进行最大公约数的求解，进而得到其最小公倍数，这个结果即为3个数的最小公倍数 
     * @param a
     * @param b
     * @param c
     * @return finalRes
     */
    public int caculate5(int a,int b,int c){
        int res=ca.cacluate2(a, b);
        res=a*b/res;
        int finalRes=ca.cacluate2(c, res);
        finalRes=c*res/finalRes;
        return finalRes;
    }
    /**
     * 
     * @Description:该方法用于计算3个数的最小公倍数，穷举法
     * 根据最小公倍数的与最大公约数的关系，先利用辗转相除的方法求解任意两个数的最小公约数，进而得到这两个数的最小公倍数，
     * 然后将结果与第三个进行最大公约数的求解，进而得到其最小公倍数，这个结果即为3个数的最小公倍数 
     * @param a
     * @param b
     * @param c
     * @return finalRes
     */
    public int caculate6(int a,int b,int c){
        int res=ca.cacluate3(a, b);
        res=a*b/res;
        int finalRes=ca.cacluate3(c, res);
        finalRes=c*res/finalRes;
        return finalRes;
    }
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        System.out.println("请输入第一个正整数");
        int a = s.nextInt();
        System.out.println("请输入第二个正整数");
        int b = s.nextInt();
        System.out.println("请输入第三个正整数");
        int d = s.nextInt();
        Calculates c=new Calculates();
        System.out.println("最大公约数为：");
        System.out.println("算法一的结果"+c.calculate1(a, b,d));
        System.out.println("算法二的结果"+c.caculate2(a, b,d));
        System.out.println("算法三的结果"+c.caculate3(a, b,d));
         System.out.println("最小公倍数为：");
        System.out.println("算法一的结果"+c.caculate4(a, b,d));
        System.out.println("算法二的结果"+c.caculate5(a, b,d));
        System.out.println("算法三的结果"+c.caculate6(a, b,d));

    }
}