Java十大算法（1）：二分查找算法、分治算法、动态规划算法、KMP查找算法、贪心算法_为什么有人说二分搜索算法是利用动态规划实现

1、二分查找算法

1. 之前有说过二分查找算法，是使用递归的方式，下面我们来写一个二分查找算法的非递归方式
2. 二分查找法只适用于从有序的数列中进行查找(比如数字和字母等)，将数列排序后再进行查找
3. 二分查找法的运行时间为对数时间O(㏒₂n)，即查找到需要的目标位置最多只需要㏒₂n步，假设从[0,99]的队列(100个数，即n=100)中寻到目标数30，则需要查找步数为㏒₂100 ，即最多需要查找7次( 2 ⁶ < 100 < 2⁷)。

二分查找算法(非递归)代码实现：

public class BinarySearch {

	public static void main(String[] args) {
		
		//测试：
		int[] arr= {1,3, 8, 10, 11, 67, 100};
		int index=binarySearch(arr, 111);
		System.out.println("index="+index);
	}
	
	//二分查找非递归实现
	/**
	 * 
	 * @param arr 待查找的数组，升序排列
	 * @param target 需查找的数
	 * @return 对应下标，-1表示没有找到
	 */
	public static int binarySearch(int[] arr, int target) {
		int left=0;
		int right= arr.length-1;
		
		while(left<=right) {
			int mid = (left+right)/2;
			if(arr[mid]==target) {
				return mid;
			}else if(arr[mid]>target) {
				right=mid-1;//向左查找
			}else {
				left=mid+1;//向右查找
			}
		}
		return -1;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

2、分治算法（汉诺塔问题）

分治算法介绍：

1. 分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)，傅立叶变换(快速傅立叶变换)……
2. 分治算法可以求解的一些经典问题：
   (1) 二分搜索
   (2) 大整数乘法
   (3) 棋盘覆盖
   (4) 合并排序
   (5) 快速排序
   (6) 线性时间选择
   (7) 最接近点对问题
   (8) 循环赛日程表
   (9) 汉诺塔

分治法在每一层递归上都有三个步骤：

1. 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题
2. 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题
3. 合并：将各个子问题的解合并为原问题的解。

分治算法最佳实践-汉诺塔问题：

1. 如果是有一个盘， 则直接A->C
2. 如果我们有 n >= 2 情况，我们总是可以看做是两个盘 1.最下边的盘 2. 上面的所有盘
   (1) 先把最上面的盘 A->B
   (2) 把最下边的盘 A->C
   (3) 把B塔的所有盘 从 B->C

代码实现：

public class HanoiTower {

	public static void main(String[] args) {
		hanoiTower(3, 'A', 'B', 'C');
	}
	
	//汉诺塔移动方法
	public static void hanoiTower(int num,char a,char b, char c) {
		//如果只有一个盘
		if(num==1) {
			System.out.println("第1个盘"+a+"->"+c);
		}else {
			//如果我们有 n >= 2 情况，我们总是可以看做是两个盘 1.最下边的一个盘 2.上面的所有盘
			//1.先把 上面的所有盘 A->B，移动过程中会使用C
			hanoiTower(num-1, a, c, b);
			//把最下边的盘 A->C
			System.out.println("第"+num+"个盘"+a+"->"+c);
			//把B塔的所有盘 从 B->C，移动过程中会使用A
			hanoiTower(num-1, b, a, c);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3、动态规划算法

动态规划算法介绍：

1. 动态规划(Dynamic Programming)算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法。
2. 动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
3. 与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。 (即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解 )
4. 动态规划可以通过填表的方式来逐步推进，得到最优解。

动态规划算法最佳实践—背包问题：
背包问题：有一个背包，容量为4磅 ， 现有如下物品：

1. 要求达到的目标为装入的背包的总价值最大，并且重量不超出
2. 要求装入的物品不能重复

思路分析：
算法的主要思想，利用动态规划来解决。每次遍历到的第i个物品，根据w[i]和val[i]来确定是否需要将该物品放入背包中。即对于给定的n个物品，设val[i]、w[i]分别为第i个物品的价值和重量，C为背包的容量。再令v[i][j]表示在前i个物品中能够装入容量为j的背包中的最大价值。则我们有下面的结果：

1. v[i][0]=v[0][j]=0;
   表示填入表第一行和第一列是0
2. 当w[i]> j 时：v[i][j]=v[i-1][j];
   当准备加入新增的商品的容量大于当前背包的容量时，就直接使用上一个单元格的装入策略。
3. 当j>=w[i]时： v[i][j]=max{v[i-1][j], val[i]+v[i-1][j-w[i]]};
   当 准备加入的新增的商品的容量小于等于当前背包的容量，装入的方式：
   v[i-1][j]： 就是上一个单元格的装入的最大值
   val[i]：表示当前商品的价值
   v[i-1][j-w[i]]：装入i-1商品，到剩余空间j-w[i]的最大值
   然后取最大的价值装入即可

最后得到的结果为：

最后一个（红色字体）即为最优的装法。

代码实现：

public class KnapsackProblem {

	public static void main(String[] args) {
		int[] w = { 1, 4, 3 };// 物品的重量
		int[] val = { 1500, 3000, 2000 };// 物品的价值
		int m = 4;// 背包的容量
		int n = val.length;// 物品的个数

		// 创建二维数组
		int[][] v = new int[n + 1][m + 1];// 表示在前i个物品中能够装入容量为j的背包中的最大价值
		// 为了记录放入商品的情况，我们再创建一个二维数组
		int[][] path = new int[n + 1][m + 1];

		// 初始化第一行和第一列(也可以不处理，因为默认就为0)
		for (int i = 0; i < n + 1; i++) {// 第一列设为0
			v[i][0] = 0;
		}
		for (int i = 0; i < m + 1; i++) {// 第一列设为0
			v[0][i] = 0;
		}

		// 根据公式进行动态规划处理
		for (int i = 1; i < n + 1; i++) {
			for (int j = 1; j < m + 1; j++) {
				if (w[i - 1] > j) {// 因为i是从1开始的表示第一个物品，但第一个物品对应的重量在w数组中对应数值的下标为0，所以需要-1
					v[i][j] = v[i - 1][j];
				} else {// 同理，val和w所对应的都需要-1
					// v[i][j] = Math.max(v[i - 1][j], val[i - 1] + v[i - 1][j - w[i - 1]]);
					// 为了记录，不能简单地直接使用这个公式
					// 需要使用if-else来处理
					if (v[i - 1][j] < val[i - 1] + v[i - 1][j - w[i - 1]]) {
						v[i][j] = val[i - 1] + v[i - 1][j - w[i - 1]];// 即我们将第i个商品放入了背包
						path[i][j] = 1;
					} else {
						v[i][j] = v[i - 1][j];
					}
				}
			}
		}

		// 输出二维数组
		for (int i = 0; i < n + 1; i++) {
			for (int j = 0; j < m + 1; j++) {
				System.out.print(v[i][j] + "\t");
			}
			System.out.println();
		}

		// 输出最后放入的那些商品
		int i = n;// 行的最大下标
		int j = m;// 列的最大下标
		while (i > 0 && j > 0) {// 从path的最后开始找
			if (path[i][j] == 1) {
				System.out.printf("第%d个商品放入到背包\n", i);
				j -= w[i - 1];
			}
			i--;
		}
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

结果：

0		0		0		0		0	
0		1500	1500	1500	1500	
0		1500	1500	1500	3000	
0		1500	1500	2000	3500	
第3个商品放入到背包
第1个商品放入到背包
1
2
3
4
5
6

4、KMP查找算法

应用场景-字符串匹配问题：

暴力匹配算法：

1. 如果当前字符匹配成功（即str1[i] == str2[j]），则i++，j++，继续匹配下一个字符
2. 如果失配（即str1[i]! = str2[j]），令i = i - (j - 1)，j = 0。相当于每次匹配失败时，i 回溯，j被置为0。
3. 用暴力方法解决的话就会有大量的回溯，每次只移动一位，若是不匹配，移动到下一位接着判断，浪费了大量的时间。
4. 暴力匹配算法实现：

public class ViolenceMatch {

	public static void main(String[] args) {
		String str1 = "BBC ABCDAB ABCDABCDABDE";
		String str2 = "ABCDABD";
		int index = violenceMatch(str1, str2);
		System.out.println(index);
	}

	// 暴力匹配方法
	public static int violenceMatch(String str1, String str2) {
		char[] s1 = str1.toCharArray();
		char[] s2 = str2.toCharArray();

		int s1Len = s1.length;
		int s2Len = s2.length;

		int i = 0;// 指向s1
		int j = 0;// 指向s2

		while (i < s1Len && j < s2Len) {
			if (s1[i] == s2[j]) {
				i++;
				j++;
			} else {
				i = i - (j - 1);
				j = 0;
			}
		}
		if (j == s2Len) {
			return i - j;
		} else {
			return -1;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

KMP算法介绍：

5. KMP是一个解决模式串在文本串是否出现过，如果出现过，最早出现的位置的经典算法。
6. Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP算法”，常用于在一个文本串S内查找一个模式串P的出现位置，这个算法由Donald Knuth、Vaughan Pratt、James H.Morris三人于1977年联合发表，故取这3人的姓氏命名此算法。
7. KMP方法算法就利用之前判断过信息，通过一个next数组，保存模式串中前后最长公共子序列的长度，每次回溯时，通过next数组找到，前面匹配过的位置，省去了大量的计算时间。

图解：

代码实现：

import java.util.Arrays;

public class KMPAlgorithm {

	public static void main(String[] args) {

		String str1 = "BBC ABCDAB ABCDABCDABDE";
		String str2 = "ABCDABD";
		int[] next = kmpNext(str2);
		System.out.println(Arrays.toString(next));
		int index = kmpSearch(str1, str2, next);
		System.out.println("index = " + index);
	}

	// KMP算法
	public static int kmpSearch(String str1, String str2, int[] next) {
		// 遍历
		for (int i = 0, j = 0; i < str1.length(); i++) {
			while (j > 0 && str1.charAt(i) != str2.charAt(j)) {
				j = next[j - 1];
			}
			if (str1.charAt(i) == str2.charAt(j)) {
				j++;
			}
			if (j == str2.length()) {// 找到了
				return i - j + 1;
			}
		}
		return -1;
	}

	// 获取一个字符串的部分匹配表
	public static int[] kmpNext(String dest) {
		// 创建一个next数组保存部分匹配表
		int[] next = new int[dest.length()];
		next[0] = 0;// 如果字符串长度为1，部分匹配值就为0
		for (int i = 1, j = 0; i < dest.length(); i++) {
			while (j > 0 && dest.charAt(i) != dest.charAt(j)) {
				j = next[j - 1];
			}
			if (dest.charAt(i) == dest.charAt(j)) {
				j++;
			}
			next[i] = j;
		}
		return next;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

结果：

[0, 0, 0, 0, 1, 2, 0]
index = 15
1
2

具体的可以参考资料：KMP算法详解

5、贪心算法

贪心算法介绍：

1. 贪婪算法(贪心算法)是指在对问题进行求解时，在每一步选择中都采取最好或者最优(即最有利)的选择，从而希望能够导致结果是最好或者最优的算法。
2. 贪婪算法所得到的结果不一定是最优的结果(有时候会是最优解)，但是都是相对近似(接近)最优解的结果。

贪心算法最佳应用—集合覆盖：
假设存在如下表的需要付费的广播台，以及广播台信号可以覆盖的地区。 如何选择最少的广播台，让所有的地区都可以接收到信号。

思路分析：

1. 遍历所有的广播电台, 找到一个覆盖了最多未覆盖的地区的电台(此电台可能包含一些已覆盖的地区，但没有关系）。
2. 将这个电台加入到一个集合中(比如ArrayList), 想办法把该电台覆盖的地区在下次比较时去掉。
3. 重复第1步直到覆盖了全部的地区。

代码实现：

package greedy;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;

public class GreedyAlgorithm {

	public static void main(String[] args) {
		// 创建广播点台
		HashMap<String, HashSet<String>> broadCasts = new HashMap<String, HashSet<String>>();
		// 将各个电台放入到broadCasts中
		HashSet<String> hashSet1 = new HashSet<String>();
		hashSet1.add("北京");
		hashSet1.add("上海");
		hashSet1.add("天津");

		HashSet<String> hashSet2 = new HashSet<String>();
		hashSet2.add("广州");
		hashSet2.add("北京");
		hashSet2.add("深圳");

		HashSet<String> hashSet3 = new HashSet<String>();
		hashSet3.add("成都");
		hashSet3.add("上海");
		hashSet3.add("杭州");

		HashSet<String> hashSet4 = new HashSet<String>();
		hashSet4.add("上海");
		hashSet4.add("天津");

		HashSet<String> hashSet5 = new HashSet<String>();
		hashSet5.add("杭州");
		hashSet5.add("大连");

		// 加入到map
		broadCasts.put("K1", hashSet1);
		broadCasts.put("K2", hashSet2);
		broadCasts.put("K3", hashSet3);
		broadCasts.put("K4", hashSet4);
		broadCasts.put("K5", hashSet5);

		// allAreas存放所有地区
		HashSet<String> allAreas = new HashSet<String>();
		allAreas.add("北京");
		allAreas.add("上海");
		allAreas.add("天津");
		allAreas.add("广州");
		allAreas.add("深圳");
		allAreas.add("成都");
		allAreas.add("杭州");
		allAreas.add("大连");

		// 创建一个ArrayList，存放选择的电台集合
		ArrayList<String> selects = new ArrayList<String>();

		// 定义一个临时集合，在遍历过程中，存放遍历过程中电台覆盖的地区和当前还未覆盖的地区的交集
		HashSet<String> tempSet1 = new HashSet<String>();
		HashSet<String> tempSet2 = new HashSet<String>();

		// 定义一个maxKey，保存在一次遍历中，能覆盖最多未覆盖地区所对应的电台的key
		String maxKey = null;
		while (allAreas.size() != 0) {// 如果不为0，则表示还未覆盖到所有地区，则继续选择

			// 每进行一次while需要把maxKey置空
			maxKey = null;

			// 遍历broadCasts，取出对应的key
			for (String key : broadCasts.keySet()) {
				// 每进行一次for，需要将tempSet清空
				tempSet1.clear();
				tempSet2.clear();
				// 当前的key所能覆盖的地区
				tempSet1.addAll(broadCasts.get(key));
				// 存放目前来说拥有最大的覆盖地区的电台的覆盖地区
				if (maxKey != null) {
					tempSet2.addAll(broadCasts.get(maxKey));
				}
				// 求出tempSet1和allAreas两个集合的交集，并将结果赋给tempSet1集合
				tempSet1.retainAll(allAreas);
				// 求出tempSet2和allAreas两个集合的交集，并将结果赋给tempSet2集合
				tempSet2.retainAll(allAreas);
				// 如果当前这个集合所包含的未覆盖的地区的数量，比maxKey指向的集合地区还多，就需要重置maxKey
				if (tempSet1.size() > 0 && (maxKey == null || tempSet1.size() > tempSet2.size())) {
					// tempSet1.size() > tempSet2.size()体现了贪心算法的特点，每次都选择最优的
					maxKey = key;
				}
			}
			// maxKey!=null，就应该将maxKey加入selects中
			if (maxKey != null) {
				selects.add(maxKey);
				// 将maxKey指向的广播电台覆盖的地区从allAreas中去掉
				allAreas.removeAll(broadCasts.get(maxKey));
			}
		}
		System.out.println("选择的结果为：" + selects);// K1,K2,K3,K5
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

结果：

选择的结果为：[K1, K2, K3, K5]
1

贪心算法注意事项和细节：

1. 贪婪算法所得到的结果不一定是最优的结果（有时候会是最优解），但是都是相对近似（接近）最优解的结果
2. 比如上题的算法选出的是K1，K2，K3，K5，符合覆盖了全部的地区
3. 但是我们发现 K2，K3，K4，K5也可以覆盖全部地区，如果K2 的使用成本低于K1,那么我们上题的 K1，K2，K3，K5虽然是满足条件，但是并不是最优的。