java实现经典算法实例详解（递归，穷举，贪心，分治，动态规划，回溯，其他）求职必备

介绍一些经典算法，递归（二分法查找、欧几里得算法、汉诺塔、阶乘求解算法），穷举（泊松算法），贪心（背包），分治（循环赛日常表、棋盘问题），动态规划（最长公共子序列），回溯（八皇后），其他算法（约瑟夫杀人法）。

求职必须会的几类算法，建议可以用这几个例子做这几个算法的入门练习（已经写了很详细的解释），了解算法思想之后再刷题会好很多。

写在最前边：
递归，分治，归并等等这种按规律依次拆开，又依次合并，循环迭代的方式最开始那步都是等待变量变成1（递归的出口），也就是分到1个单位，然后再一一合并回去。
eg:
if (size == 1){
return;
}

1.递归

1.1汉诺塔

解释：现在要把三个盘子从A挪动到C：

• 要把A最下边的那个盘子从A挪到C，要先把上边两个借助C挪到B；
• 然后把最下边那个大的从A挪到C；
• 再把剩下（目前在B上）的两个借助A挪到B（剩下两个的挪法，同上边挪动最大盘子的方法）。

代码实现：

package com.algorithm.recursion;

/**
 * recursion:递归；
 * 汉诺塔:递归
 */
public class HanNota {
    private int i = 1;
    public void hanNota(int n,char from,char dependOn,char to){
        //n表示在挪第n个盘子；
        if (n == 1){
            //当只有一个盘子要挪动的时候，直接从from挪动到to;（表示的是被挪动柱子上最上边的一个盘子）
            move(1,from,to);
        }else{
            hanNota(n-1, from, to, dependOn);//先将n-1个盘子从A利用C挪到B,n会一直减，直到n = 1,直接从from挪动到to
            move(n, from, to);                  //将n这个盘子（底盘）从A挪到C;
            hanNota(n-1, dependOn, from, to);//将n-1个盘子从B利用A挪到C;
        }

    }

    private void move(int n, char from, char to) {
        //移动过去之后直接打印作表示就可以；
        System.out.println("第" + i++ +"步：第" + n +"个盘子从" + from + "------->" + to);
       /* System.out.println("第" + i++ +"步从" + from + "------->" + to);*/
    }

    public static void main(String[] args){
        HanNota hn = new HanNota();
        hn.hanNota(3, 'A', 'B', 'C');
    }

}

1.2欧几里德法求两个数的最大公约数

代码：

package com.algorithm.recursion;

/**
 * 求一个数的最大公约数（简称：gcd）(欧几里德原理)
 * （m>n）m和n的最大公约数 = n 和m%n的最大公约数
 *   eg: 36 和 24  12      24和36%24=12     12和24%12=0  则只剩余12；
 */
public class Gcd {
    public int gcd(int m ,int n){
        if (n == 0){
            return m;
        }else {
            return gcd(n, m%n);
        }
    }

    public static void main(String[] args){
        Gcd test = new Gcd();
        System.out.println(test.gcd(99, 11));
    }
}

1.3二分法查找

代码：

package com.algorithm.recursion;
import com.sort.MergeSortSelf;

/**
 * @author yn
 * @description 二分法查找:递归的方式和非递归的方式；
 */
public class BinarySearchSelf {
    /**
     * 递归的方式
     * @param elem
     * @param array
     * @param low
     * @param high
     * @return
     */
    public int binarySearch(int elem,int[] array,int low,int high){
        if (low>high){
            return -1;
        }
        int middle = (low+high)/2;
        if (array[middle] == elem){
            System.out.println("找到这个元素的对应下标值为：" + middle);
            return middle;
        }
        if (array[middle] < elem){
            //找右边
            return binarySearch(elem, array, middle+1, high);
        }
        if (array[middle] > elem){
            //找左边
            return binarySearch(elem, array, low, middle-1);
        }
        return -1;
    }

    /**
     * 非递归的方式
     * @param array
     * @param elem
     * @return
     */
    public int directBinarySearch(int[] array,int elem){
        int low = 0;
        int high = array.length-1;
        while (low <= high){
            int middle = (low+high)/2;
            if(elem>array[middle]){
                //往右边找
                low = middle+1;
            }else if (elem<array[middle]){
                //往左边找
                high = middle-1;
            }else {
                System.out.println("找到这个元素的下标：" + middle);
                return middle;