【数据结构(十三·程序员常用的10种算法)】上

---

1. 二分查找算法(非递归)

1.1. 介绍

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

1.2. 代码实现

数组 {1,3, 8, 10, 11, 67, 100}, 编程实现二分查找， 要求使用非递归的方式完成.

1. 思路分析：（前面章节已讲过）
2. 代码实现：

package com.cumt509.binarysearchnorecursion;

public class BinarySearchNoRecur {

	public static void main(String[] args) {
		// 测试
		int[] arr = { 1, 3, 8, 10, 11, 67, 100 };
		int index = binarySearch(arr, 1);
		System.out.println("index = " + index);// 0

	}

	// 二分查找的非递归实现
	/**
	 * 
	 * @param arr    待查找的数组，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;
	}

}

2. 分治算法

2.1. 分治算法介绍

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

2.2. 分治算法的基本步骤

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

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

2.3. 分治(Divide-and-Conquer§)算法设计模式

$if(|P|)\le n_0$：如果一个问题$P$规模为$|P|$ 不超过阈值 $n_0$，那么就表示：问题已容易直接解出，不必再继续分解。
$thenreturn(ADHOC(P))$：就返回分治法中的基本子算法 $ADHOC(\ast )$ 的解$ADHOC(P)$

即，将$P$分解为较小的子问题 $P_1,P_2,...,P_k.(其中，1<i<k)$，通过分治法求出每个子问题的解：$y_i=Divide\_and\_Conquer(P_i)$，然后合并子问题返回最终结果 $T=MERGE(y_1,y_2,..,y_k)$

    其中$|P|$表示问题$P$的规模；$n_0$为一阈值，表示当问题$P$的规模不超过$n_0$时，问题已容易直接解出，不必再继续分解。$ADHOC(P)$是该分治法中的基本子算法，用于直接解小规模的问题$P$。因此，当P的规模不超过$n_0$时直接用算法$ADHOC(P)$求解。算法$MERGE(y_1,y_2...,y_k)$是该分治法中的合并子算法，用于将$P$的子问题$P_1,P_2...,P_k$的相应的解$y_1,y_2...,y_k$合并为$P$的解。

2.4. 分治算法最佳实践-汉诺塔

汉诺塔的传说：
    汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着 64 片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

    假如每秒钟一次，共需多长时间呢？移完这些金片需要 5845.54 亿年以上，太阳系的预期寿命据说也就是数百亿年。真的过了 5845.54 亿年，地球上的一切生命，连同梵塔、庙宇等，都早已经灰飞烟灭。

问题再描述：
    有A、B、C三根柱子，需要将A柱子上的所有盘（假设是n个）移动到C柱子上

思路分析：
第一种情况：
    如果是有n=1， 直接将A柱子上的盘移动到C柱子上
第一种情况：
    如果是 n >= 2 情况，可以看作是两个盘：最下面的盘作为一个盘，其余上面的盘看作一个盘
        ① 先把 最上面的盘 由A移动到B
        ② 把最下边的盘 由A移动到C
        ③ 把 B 塔的所有盘 从B移动到C

汉诺塔游戏的代码实现：

package dac;

public class Hanoitower {

	public static void main(String[] args) {
		hanoiTower(5, '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);
			// 2.把最下面的盘由A->C
			System.out.println("第" + num + "个盘从" + a + "->" + c);
			// 3.把B塔的所有盘从B->C，移动过程使用到a塔
			hanoiTower(num - 1, b, a, c);
		}
	}
}

3. 动态规划算法

3.1. 应用场景-背包问题

背包问题：
    有一个背包，容量为 4 磅 ， 现有如下物品

物品	重量	价格
吉他	1	1500
音响	4	3000
电脑	3	2000

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

背包问题解释：
    1. 主要是指一个给定容量的背包、若干具有一定价值和重量的物品，如何选择物品放入背包使物品的价值最大。其中又分 “0-1背包”和“完全背包”(“完全背包”指的是：每种物品都有无限件可用)
    2. 这里的问题属于 “0-1背包”，即每个物品最多放一个。而“无限(完全)背包”可以转化为 “0-1背包”。

3.2. 动态规划算法介绍

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

3.3. 动态规划算法最佳实践-背包问题

背包问题：
    有一个背包，容量为 4 磅 ， 现有如下物品

物品	重量	价格
吉他	1	1500
音响	4	3000
电脑	3	2000

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

思路分析：
算法的主要思想，利用动态规划来解决：

    每次遍历到的第 $i$ 个物品，根据 $w[i]$ 和 $v[i]$ 来确定是否需要将该物品放入背包中。即对于给定的 $n$ 个物品，设 $v[i]$ 、$w[i]$ 分别为第 $i$ 个物品的价值和重量，$C$ 为背包的容量。再令 $v[i][j]$ 表示在前 $i$ 个物品中能够装入容量为 $j$ 的背包中的最大价值（一定要注意：这里的前 $i$ 个物品并表示有前 $i$ 个物品可供选择，对应表格的第 $i$ 行）。

则我们有下面的结果：
    (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],v[i]+v[i-1][j-w[i]\}$ // 当 准备加入的新增的商品的容量小于等于当前背包的容量

装入的方式：
    ① $v[i-1][j]$： 就是上一个单元格的装入的最大值
    ② $v[i]$ : 表示当前商品的价值
    ③ $v[i-1][j-w[i]]$ ： 装入 $i-1$ 商品，到剩余空间 $j-w[i]$ 的最大值
    当 $j>=w[i]$ 时：$v[i][j]=max$$\{v[i-1][j],v[i]+v[i-1][j-w[i]]\}$
    
举例：
当执行到 $i=3;j=4$，有：
$w[i]=w[3]=3$
$j>=w[i]$ => $4>=3$
$v[3][4]=max$$\{v[2][4],v[3]+v[2][1]\}=max$$\{3000,2000+1500\}=2000+1500=3500$

代码实现：

package dynamic;

public class KnapsackProblem {

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

		// 为了记录放物品的情况，我们定义一个二维数组
		int[][] path = new int[n + 1][m + 1];

		// 创建二维数组
		// v[i][j] 表示在前i个物品中能够装入容量为j的背包中的最大值
		int[][] v = new int[n + 1][m + 1];

		// 初始化第一行和第一列，这里在本程序中，可以不去处理，因为默认就是0
		for (int i = 0; i < v.length; i++) {
			v[i][0] = 0;// 将第一列设为0
		}
		for (int i = 0; i < v[0].length; i++) {
			v[0][i] = 0;// 将第一行设为0
		}

		// 根据前面得到公式来动态规划处理
		for (int i = 1; i < v.length; i++) {// 不处理第一行，所以i是从1开始的
			for (int j = 1; j < v[0].length; j++) {// 不处理第一列，所以i是从1开始的
				// 公式
				if (w[i - 1] > j) {// 因为我们得程序i是从1开始的，因此原来公式中的w[i]修改成w[i-1]
					v[i][j] = v[i - 1][j];
				} else {
					// 说明：
					// 因为我们的i从1开始，因此公式(v[i][j]=max{v[i-1][j],val[i]+v[i-1][j-w[i]})需要调整成
					// v[i][j] = Math.max(v[i - 1][j], val[i - 1] + v[i - 1][j - w[i - 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]];
						// 把当前的情况记录到path
						path[i][j] = 1;
					} else {
						v[i][j] = v[i - 1][j];
					}

				}
			}
		}

		// 输出一下v 看看目前的情况
		for (int i = 0; i < v.length; i++) {
			for (int j = 0; j < v[i].length; j++) {
				System.out.print(v[i][j] + " ");
			}
			System.out.println();
		}

		System.out.println("====================================");
		// 输出最后我们是放入哪些物品
		// 遍历path，这样输出会把所有的放入情况都得到，其实我们只需要最后的放入
//		for (int i = 0; i < path.length; i++) {
//			for (int j = 0; j < path[i].length; j++) {
//				if (path[i][j] == 1) {
//					System.out.printf("第%d个物品放入到背包\n", i);
//				}
//			}
//		}

		// 正确做法
		int i = path.length - 1;// 行的最大下标
		int j = path[0].length - 1;// 列的最大下标
		while (i > 0 && j > 0) {// 从path的最后开始找
			if (path[i][j] == 1) {
				System.out.printf("第%d个物品放入到背包\n", i);
				j -= w[i - 1];// w[i-1]
			}
			i--;
		}

	}

}

运行结果：

注意：最后的输出是逆序的

4. KMP 算法

4.1. 应用场景

字符串匹配问题：：

1. 有一个字符串 $str1=“逸夫楼逸夫楼你逸夫逸夫楼你逸夫楼你逸夫你好”$，和一个子串 $str2=“逸夫楼你逸夫你”$
2. 现在要判断 $str1$ 是否含有 $str2$, 如果存在，就返回第一次出现的位置, 如果没有，则返回-1

4.2. 暴力匹配算法

如果用暴力匹配的思路，并假设现在 $str1$ 匹配到 $i$ 位置，子串 $str2$ 匹配到 $j$ 位置，则有:

1. 如果当前字符匹配成功（即 $str1[i]==str2[j]$），则 $i++$，$j++$，继续匹配下一个字符
2. 如果失配（即 $str1[i]!=str2[j]$），令 $i=i-(j-1)，j=0$。相当于每次匹配失败时，$i$ 回溯（回溯到上一轮第一个字符匹配成功的下一个字符，从这里再次开始匹配），$j$ 被置为 0。

用暴力方法解决的话就会有大量的回溯，每次只移动一位，若是不匹配，移动到下一位接着判断，浪费了大量的时间。(不可行!)

暴力匹配算法实现：

package kmp;

public class ViolenceMatch {

	public static void main(String[] args) {
		// 测试暴力匹配算法
		String str1 = "逸夫楼 逸夫楼你逸夫 逸夫楼你逸夫楼你逸夫你好";
		String str2 = "逸夫楼你逸夫你";
		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;
		int j = 0;

		while (i < s1Len && j < s2Len) {// 保证匹配时不越界
			if (s1[i] == s2[j]) {// 单个字符匹配成功
				i++;
				j++;
			} else {// 没有匹配成功
					// 如果失配，令i = i - (j - 1), j = 0
				i = i - (j - 1);
				j = 0;
			}

		}

		// 判断是否匹配成功
		if (j == s2Len) {
			return i - j;
		} else {
			return -1;
		}
	}

}

4.3. KMP算法介绍

    Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP 算法”，常用于在一个文本串 S 内查找一个模式串 P 的出现位置，这个算法由 Donald Knuth、Vaughan Pratt、James H. Morris 三人于 1977 年联合发表，故取这 3 人的姓氏命名此算法。
    KMP 是一个解决模式串在文本串是否出现过，如果出现过，返回最早出现的位置（经典算法）

    KMP 方法算法就利用之前判断过信息，通过一个 next 数组，保存模式串中前后最长公共子序列的长度，每次回溯时，通过 next 数组找到，前面匹配过的位置，省去了大量的计算时间
    参考资料：https://www.cnblogs.com/ZuoAndFutureGirl/p/9028287.htm

4.4. KMP 算法最佳应用-字符串匹配问题

字符串匹配问题：
    有一个字符串 $str1=“BBCABCDABABCDABCDABDE”$，和一个子串 $str2=“ABCDABD”$
    现在要判断 $str1$ 是否含有 $str2$， 如果存在，就返回第一次出现的位置, 如果没有，则返回-1
    要求：使用 KMP 算法完成判断，不能使用简单的暴力匹配算法。

4.4.1. 思路分析图解

    1. 首先，用 $Str1$ 的第一个字符和 $Str2$ 的第一个字符去比较，不符合，搜索关键词 向后移动一位

    2. 重复第一步，还是不符合，再后移

    3. 一直重复，直到 $Str1$ 有一个字符与 $Str2$ 的第一个字符符合为止

    4. 接着比较字符串和搜索词的下一个字符，还是符合。

    5. 遇到 $Str1$ 有一个字符与 $Str2$ 对应的字符不符合。

    6. 这时候，想到的是继续遍历 $Str1$ 的下一个字符，重复第 1 步。但这样做，其实是很不明智的，因为此时 $BCD$ 已经比较过了（肯定和 $Str2$字符串 中的 $A$ 不匹配），没有必要再做重复的工作，一个基本事实是，当$空格$与 $D$ 不匹配时，你其实知道前面六个字符是"$ABCDAB$"。
      KMP 算法的想法是，设法利用这个已知信息，不要把“搜索位置”移回已经比较过的位置，继续把它向后移，这样就提高了效率。

    7. 怎么做到把上面重复的步骤省略掉？
      可以对 $Str2$ 计算出一张《部分匹配表》（如何产生《部分匹配表》在后面介绍）

    8. 已知 $空格$ 与 $D$ 不匹配时，前面六个字符"$ABCDAB$"是匹配的。查表可知，最后一个匹配字符 $B$ 对应的“部分匹配值”为 2，因此按照下面的公式算出向后移动的位数：
    移动位数 = 已匹配的字符数 - 对应的部分匹配值
    即：移动位数 = 6 - 2 = 4，所以将搜索词向后移动 4 位。

    9. 因为 $空格$ 与 $Ｃ$ 不匹配，搜索词还要继续往后移。这时，已匹配的字符数为 2（“$AB$”），对应的“部分匹配值”为 0。所以，移动位数 = 2 - 0 = 2，于是将搜索词向后移 2 位。

    10. 因为$空格$与 $A$ 不匹配，继续后移一位。

    11. 逐位比较，直到发现 $C$ 与 $D$ 不匹配。于是，移动位数 = 6 - 2 = 4，继续将搜索词向后移动 4 位。

    12. 逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。

    如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动 7 位，这里就不再重复了。

介绍《部分匹配表》怎么产生的：
 
先介绍前缀，后缀是什么

 
部分匹配值就是前缀和后缀的最长的共有元素的长度。以“ABCDABD”为例，
    “A”的前缀和后缀都为空集，共有元素的长度为 0；
    “AB”的前缀为[A]，后缀为[B]，共有元素的长度为 0；
    “ABC”的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度 0；
    “ABCD”的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为 0；
    “ABCDA”的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为“A”，长度为 1；
    “ABCDAB”的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为“AB”，长度为 2；
    “ABCDABD”的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为 0。
    
    “部分匹配”的实质是，有时候，字符串头部和尾部会有重复。比如，”ABCDAB”之中有两个”AB”，那么它的”部分匹配值”就是 2（”AB”的长度）。搜索词移动的时候，第一个”AB”向后移动 4 位（字符串长度- 部分匹配值），就可以来到第二个”AB”的位置。
 

4.4.2. 代码实现

package kmp;

import java.util.Arrays;

public class KMPAlgorithm {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str1 = "BBC ABCDAB ABCDABCDABDE";
		String str2 = "ABCDABD";

		int[] next = kmpNext("ABCDABD");
		System.out.println("next=" + Arrays.toString(next));

		int index = kmpSearch(str1, str2, next);
		System.out.println("index=" + index);

	}

	// kmp搜索算法
	/**
	 * 
	 * @param str1 源字符串
	 * @param str2 子串
	 * @param next 部分匹配表，是子串对应的部分匹配表
	 * @return 如果是-1就是没有匹配到，否则返回第一个匹配的位置
	 */
	public static int kmpSearch(String str1, String str2, int[] next) {

		// 遍历
		for (int i = 0, j = 0; i < str1.length(); i++) {

			// 需要考虑处理str1.charAt(i) ！= str2.charAt(j)，调整j的大小
			// kmp算法核心点
			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++) {

			// 当dest.charAt(i) != dest.charAt(j) 满足时，我们需要从next[j-1]获取新的j
			// 直到我们发现 有 dest.charAt(i) == dest.charAt(j) 成立才退出
			// 这是kmp算法的核心点
			while (j > 0 && dest.charAt(i) != dest.charAt(j)) {
				j = next[j - 1];
			}

			// 当dest.charAt(i) == dest.charAt(j) 满足时，部分匹配值就+1
			if (dest.charAt(i) == dest.charAt(j)) {
				j++;
			}
			next[i] = j;
		}
		return next;
	}

}

5. 贪心算法

5.1. 应用场景-集合覆盖问题

    假设存在下面需要付费的广播台，以及广播台信号可以覆盖的地区。 如何选择最少的广播台，让所有的地区都可以接收到信号

5.2. 贪心算法介绍

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

5.3. 贪心算法最佳应用-集合覆盖

    假设存在如下表的需要付费的广播台，以及广播台信号可以覆盖的地区。 如何选择最少的广播台，让所有的地区都可以接收到信号

2. 思路分析:
       如何找出覆盖所有地区的广播台的集合呢，使用穷举法实现,列出每个可能的广播台的集合，这被称为幂集。假设总的有 n 个广播台，则广播台的组合总共有2ⁿ -1 个,假设每秒可以计算 10 个子集， 如图：

使用贪婪算法，效率高：
    目前并没有算法可以快速计算得到准备的值， 使用贪婪算法，则可以得到非常接近的解，并且效率高。选择策略上，因为需要覆盖全部地区的最小集合：
    ① 遍历所有的广播电台, 找到一个覆盖了最多地区（前面选择的电台没有覆盖到的地区）的电台(此电台可能包含一些已覆盖的地区，但没有关系）
    ② 将这个电台加入到一个集合中(比如 ArrayList)， 想办法把该电台覆盖的地区在下次比较时去掉。
    ③ 重复第 1 步直到覆盖了全部的地区

分析的图解：

注解：
    allAreas：表示没有覆盖到的地区的集合
    selects：表示已选择的电台的集合
    key：遍历的指针，找出指定电台未覆盖到的地区数
    maxKey：如果找到要加入selects集合的电台，就让maxKey指向该电台

    

第一次遍历：

第二次遍历：

第三次遍历：

第四次遍历：

代码实现：

package greedy;

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

public class GreedyAlgorithm {

	public static void main(String[] args) {
		// 创建广播电台，放入到Map
		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> tempSet = new HashSet<String>();
		// 定义一个临时的集合，
		HashSet<String> temppSet = new HashSet<String>();

		// 定义maxKey，保存在一次遍历过程中，能够覆盖最大未覆盖的地区对应的电台的key
		// 如果maxKey不为null，则会加入到selects
		String maxKey = null;
		while (allAreas.size() != 0) {// 如果allAreas不为0，则表示还没有覆盖到所有的地区
			// 每进行一次while，需要
			maxKey = null;
			// 遍历broadcasts，取出对应的key
			for (String key : broadcasts.keySet()) {
				// 每进行一次for
				tempSet.clear();
				temppSet.clear();
				// 当前这个key能够覆盖的地区
				HashSet<String> areas = broadcasts.get(key);
				tempSet.addAll(areas);
				
				if (maxKey != null) {
					temppSet.addAll(broadcasts.get(maxKey));
					temppSet.retainAll(allAreas);
				}
				
				// 求出tempSet和allAreas集合的交集，交集会赋给tempSet
				tempSet.retainAll(allAreas);
				// 如果当前这个集合包含的未覆盖地区的数量，比maxKey指向的集合地区还多
				// 就需要更新maxKey
				// tempSet.size() > boradcasts.get(maxKey).size() 体现出贪婪算法的特点，每次都选择最优的
				if (tempSet.size() > 0 && (maxKey == null || tempSet.size() > temppSet.size())) {
					maxKey = key;
				}
			}

			//
			if (maxKey != null) {
				selects.add(maxKey);
				// 将maxKey指向的广播电台覆盖的地区从allAreas去掉
				allAreas.removeAll(broadcasts.get(maxKey));
			}

		}
		System.out.println("得到的选择结果是：" + selects);

	}

}