各种方法

各种方法，积少成多。

目录

1.最小公倍数

2.List集合去重

3.质因数分解

4.最大公约数

5.欧几里得算法求最大公约数（辗转相除法）

6.质因数分解求最大公约数（两个数的共同因子相乘就是最大公约数）

7.汉诺塔问题

---

1.最小公倍数

    /**
     * 最小公倍数
     * @param m
     * @param n
     * @return
     */
    public static int multiple(int m, int n) {
        if (m==0 || n==0) {
            return 0;
        }
        int max = m>=n?m:n;
        int x = max;
        while (x%m>0 || x%n>0) {
            x+=max;
        }
        return x;
    }

2.List集合去重

（ps:泛型如果是自定义对象类型，需要重写hashCode和equals方法）

    /**
     * List集合去重
     * @param list
     * @return
     */
    public static <T> List<T> deleteRepeat(List<T> list) {
        return new ArrayList<>(new HashSet<>(list));
    }

3.质因数分解

    /**
     * 质因数分解（获取一个数的所有因子）
     * @param m
     * @return
     */
    public static List<Integer> getAllFactor(int m) {
        List<Integer> list = new ArrayList<>();
        int index = 2;
        while (index<=m && m>=2) {
            if (m%index == 0) {
                list.add(index);
                m = m/index;
                index=1;
            }
            index++;
        }
        return list;
    }

4.最大公约数

    /**
     * 最大公约数
     * @param m
     * @param n
     * @return
     */
    public static int maxDivisor(int m, int n) {
        if (m==0 || n==0) {
            return 0;
        }
        int index = m>=n?m:n;
        while (index >= 2) {
            System.out.println(index);
            if (m%index==0 && n%index==0) {
                return index;
            }
            index--;
        }
        return 0;
    }

5.欧几里得算法求最大公约数（辗转相除法）

    /**
     * 欧几里得算法求最大公约数
     * @param m
     * @param n
     * @return
     */
    public static int divisor(int m, int n) {
        if (m<n) {
            m = m^n;
            n = m^n;
            m = m^n;
        }
        if (m%n == 0) {
            return n;
        } else {
            return divisor(m, m%n);
        }
    }

6.质因数分解求最大公约数（两个数的共同因子相乘就是最大公约数）

    /**
     * 根据质因数分解法求最大公约数
     * @param m
     * @param n
     * @return
     */
    public static int getMaxFactorByFactorization(int m, int n) {
        List<Integer> mList = getAllFactor(m);
        List<Integer> nList = getAllFactor(n);
        if (mList.size()>nList.size()) {
            nList.retainAll(mList);
            return getProduct(nList);
        } else {
            mList.retainAll(nList);
            return getProduct(mList);
        }
    }

    /**
     * 获取集合中所有元素的乘积
     * @param list
     * @return
     */
    private static int getProduct(List<Integer> list) {
        int result = 1;
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()) {
            result = result*iterator.next();
        }
        return result;
    }

7.汉诺塔问题

def hanoi_tower(n, source, assist, target):
    """
    汉诺塔问题：（经典递归）
        条件：
            1.  一次只能移动一个盘子
            2.  只能小盘子放在大盘子上
        思路：
            1.  如果只有一个盘子，那么直接把盘子从“要移动的塔”，移动到“要移动到的塔”
            2.  大于一个盘子的话，那么把n-1个盘子先从“要移动的塔”，移动到“借助的塔”，
                结果“要移动的塔”上只剩下最后一个盘子，把这个盘子移动到“要移动的塔”上，
                然后再把那n-1个盘子从“借助的塔”，借助“要移动的塔”，移动到“要移动到的塔”上，
                递归调用......
        在线玩：http://www.doudou.in/game/96009.html
        二进制解释汉诺塔问题：https://www.bilibili.com/video/av7398130/
    :param n: 盘子总数
    :param source: 要移动的塔
    :param assist: 借助的塔
    :param target: 要移动到的塔
    :return:
    """
    if n == 1:
        print(source, '--->', target)
        return None
    hanoi_tower(n - 1, source, target, assist)
    print(source, '--->', target)
    hanoi_tower(n - 1, assist, source, target)


hanoi_tower(4, "A", "B", "C")