Java数据结构与算法_12 常用算法（二分查找算法、分治算法-汉诺塔问题、动态规划算法-背包问题、KMP算法-字符串匹配）

素颜马尾好姑娘i 2023-07-18 02:26 36阅读 0赞

### Java数据结构与算法\_12 常用算法 ###

*  二分查找算法
 *   *  完整代码
 *  分治算法
 *   *  示例：汉诺塔问题
     *   *  完整代码
 *  动态规划算法
 *   *  示例：背包问题
     *   *  完整代码
 *  KMP算法
 *   *  示例：字符串匹配问题
     *   *  完整代码

--------------------

***本人是个新手，写下博客用于自我复习、自我总结。  
如有错误之处，请各位大佬指出。  
学习资料来源于：尚硅谷***

--------------------

# 二分查找算法 #

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

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

--------------------

## 完整代码 ##

public class BinarySearchNoRecur { 
    
    	public static void main(String[] args) { 
    		// 测试
    		int[] arr = {  1, 3, 8, 10, 11, 67, 100 };
    		int index = binarySearch(arr, 100);
    		System.out.println("index=" + index);
    	}
    
    	// 二分查找的非递归实现
    	/** * @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;
    	}
    }

--------------------

# 分治算法 #

分治法是一种很重要的算法，字面上的解释是“分而治之”。就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础。

分治算法可以求解的一些经典问题：

*  二分搜索
 *  大整数乘法
 *  棋盘覆盖
 *  合并排序
 *  快速排序
 *  线性时间选择
 *  最接近点对问题
 *  循环赛日程表
 *  汉诺塔

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjEzOTMx_size_16_color_FFFFFF_t_70]  
其中|P|表示问题P的规模；n0为一阈值，表示当问题P的规模不超过n0时，问题已容易直接解出，不必再继续分解。ADHOC( P )是该分治法中的基本子算法，用于直接解小规模的问题P。因此，当P的规模不超过n0时直接用算法ADHOC( P )求解。算法MERGE(y1,y2,…,yk)是该分治法中的合并子算法，用于将P的子问题P1 ,P2 ,…,Pk的相应的解y1,y2,…,yk合并为P的解。

--------------------

## 示例：汉诺塔问题 ##

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjEzOTMx_size_16_color_FFFFFF_t_70 1]  
相信大家都知道汉诺塔的玩法，这里再简单说一下。（假如把盘全部搬运到C塔）

*  如果只有一个盘， A->C
 *  如果有两个盘：先把 最上面的盘 A->B ；把最下边的盘 A->C；把B塔的盘 从 B->C
 *  如果有三个盘：先把 最上面盘的 A->C ；把中间的盘 A->B ；把C塔的盘 从C->B ；把A塔最下边的盘 A->C ；再把B塔的最上面的盘 B->A ,最下面的盘 B->C ；再把A塔最后的盘 A->C 。

当然语言描述不太生动具体，在这里大家可以依自己的想法先去尝试完成汉诺塔。然后通过随着盘子的增多，也不难可以得到十分简单的道理（假如把盘全部搬运到C塔）：从最开始所作的所有动作，只是为了把 **A塔中除了最底下的盘之外的** 所有盘搬运到B塔，以便把A塔上最底下的盘搬运到C塔。之后再把B塔上所有的盘搬运到C塔。

也就是说，现在可以把它看成两个部分：①最下边的一个盘 ；②上面的所有盘

那么具体的步骤就是：

1.  把上面的所有盘 A->B， 移动过程会使用到 c
2.  把最下边的盘 A->C
3.  把B塔的所有盘 从 B->C , 移动过程会使用到 a

（当然汉诺塔不允许一次搬运多个盘，这个是整体的思路）

--------------------

### 完整代码 ###

public class Hanoitower { 
    
    	public static void main(String[] args) { 
    		hanoiTower(10, '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 { 
    			// 如果多于一个盘，我们总是可以把它看成是两部分
    			// ①最下边的一个盘
    			// ②上面的所有盘
    
    			// 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);
    
    		}
    	}
    
    }

--------------------

# 动态规划算法 #

动态规划算法**介绍**

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

--------------------

## 示例：背包问题 ##

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

![在这里插入图片描述][20200323162934102.png]

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

**思路分析：**

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

背包填表的过程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjEzOTMx_size_16_color_FFFFFF_t_70 2]  
设v\[i\]、w\[i\]分别为第i个物品的价值和重量，v\[i\]\[j\]表示在前i个物品中能够装入容量为j的背包中的最大价值

(1) 第一行和第一列是0，即： v\[i\]\[0\]=v\[0\]\[j\]=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\]\]\}

**验证：**

1.  假如现在只有 吉他(G) ， 这时不管背包容量多大，只能放一个吉他1500(G)
2.  假如有吉他和音响 , 根据（2），现在还是只能存放吉他，v\[2\]\[1\],v\[2\]\[2\],v\[2\]\[3\] ，均为1500(G)。根据（3），v\[2\]\[4\]=max\{v\[1\]\[4\],v\[2\]+v\[1\]\[4-4\]\}= max\{1500 , 3000+0\} = 3000
3.  假如三者全部考虑，  
    v\[3\]\[3\]= max\{v\[2\]\[3\],v\[3\]+v\[2\]\[3-3\]\} = max\{1500,2000+0\} = 2000  
    v\[3\]\[4\] = max \{v\[2\]\[4\], v\[3\] + v\[2\]\[1\]\} = max\{3000, 2000+1500\} = 3500

--------------------

### 完整代码 ###

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; // 物品的个数
    
    		// 创建二维数组
    		// v[i][j] 表示在前i个物品中能够装入容量为j的背包中的最大价值
    		int[][] v = new int[n + 1][m + 1];
    		// 为了记录放入商品的情况，我们定一个二维数组
    		int[][] path = 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++) { // 不处理第一列, j是从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]=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];
    					}
    
    				}
    			}
    		}
    
    		// 输出，可以看到目前的表格情况
    		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("============================");
    
    		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--;
    		}
    	}
    }

--------------------

# KMP算法 #

**算法介绍**

1.  KMP是一个解决模式串在文本串是否出现过，如果出现过，就记录最早出现的位置的经典算法。
2.  Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP算法”，常用于在一个文本串S内查找一个模式串P 的出现位置。
3.  KMP方法算法就是利用之前判断过的信息，通过一个next数组，保存模式串中前后最长公共子序列的长度，每次回溯时，通过next数组找到，前面匹配过的位置。这样可以省去大量的计算时间。

--------------------

## 示例：字符串匹配问题 ##

有一个字符串 str1= “BBC ABCDAB ABCDABCDABDE”，和一个子串 str2=“ABCDABD”

现在要判断 str1 是否含有 str2, 如果存在，就返回第一次出现的位置, 如果没有，则返回-1。

如果用暴力匹配的思路，并假设现在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。
3.  用暴力方法解决的话就会有大量的回溯，每次只移动一位，若是不匹配，移动到下一位继续判断，会浪费大量的时间。

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=" + 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; // i索引指向s1
    		int j = 0; // j索引指向s2
    		
    		while (i < s1Len && j < s2Len) { // 保证匹配时，不越界
    
    			if(s1[i] == s2[j]) { //匹配ok
    				i++;
    				j++;
    			} else {  //没有匹配成功
    				//如果失配（即str1[i]! = str2[j]），令i = i - (j - 1)，j = 0。
    				i = i - (j - 1);
    				j = 0;
    			}
    		}
    		
    		//判断是否匹配成功
    		if(j == s2Len) { 
    			return i - j;
    		} else { 
    			return -1;
    		}
    	}
    
    }

--------------------

**KMP的思路分析：**

1.  首先，用Str1的第一个字符和Str2的第一个字符去比较，不符合，关键词向后移动一位  
    ![在这里插入图片描述][20200325132528589.png]
2.  重复第一步，还是不符合，再后移  
    ![在这里插入图片描述][2020032513255582.png]
3.  一直重复，直到Str1有一个字符与Str2的第一个字符符合为止  
    ![在这里插入图片描述][20200325132656863.png]
4.  接着比较字符串和搜索词的下一个字符，还是符合。![在这里插入图片描述][20200325132730786.png]
5.  直到遇到Str1有一个字符与Str2对应的字符不符合。![在这里插入图片描述][20200325132748254.png]
6.  这时候，想到的是继续遍历Str1的下一个字符，重复第1步。(其实是很不明智的，因为此时BCD已经比较过了，没有必要再做重复的工作，一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是”ABCDAB”。KMP 算法的想法是，设法利用这个已知信息，不要把”搜索位置”移回已经比较过的位置，继续把它向后移，这样就提高了效率。)![在这里插入图片描述][2020032513283769.png]
7.  怎么把刚刚重复的步骤省略掉？可以对Str2计算出一张《部分匹配表》，这张表的产生在后面介绍 ![在这里插入图片描述][20200325132918677.png]
8.  已知空格与D不匹配时，前面六个字符”ABCDAB”是匹配的。查表可知，最后一个匹配字符B对应的”部分匹配值”为2，因此按照下面的公式算出向后移动的位数：  
    移动位数 = 已匹配的字符数 - 对应的部分匹配值  
    因为 6 - 2 等于4，所以将搜索词向后移动 4 位。
9.  因为空格与Ｃ不匹配，搜索词还要继续往后移。这时，已匹配的字符数为2（”AB”），对应的”部分匹配值”为0。所以，移动位数 = 2 - 0，结果为 2，于是将搜索词向后移 2 位。  
    ![在这里插入图片描述][20200325133220692.png]
10. 因为空格与A不匹配，继续后移一位。  
    ![在这里插入图片描述][20200325133252764.png]
11. 逐位比较，直到发现C与D不匹配。于是，移动位数 = 6 - 2，继续将搜索词向后移动 4 位。  
    ![在这里插入图片描述][20200325133312236.png]
12. 逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动 7 位，这里就不再重复了。  
    ![在这里插入图片描述][20200325133332671.png]
13. 介绍《部分匹配表》怎么产生的 ：

先介绍前缀，后缀是什么  
![在这里插入图片描述][20200325133428476.png]  
再以”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”的位置。

--------------------

### 完整代码 ###

import java.util.Arrays;
    
    public class KMPAlgorithm { 
    
    	public static void main(String[] args) { 
    		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的大小
    			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;
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjEzOTMx_size_16_color_FFFFFF_t_70]: /images/20230528/3ee96423c55a4a4f89d80087a08aa2d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjEzOTMx_size_16_color_FFFFFF_t_70 1]: /images/20230528/d15511db0444400ab6cafcc71f4b975b.png
[20200323162934102.png]: /images/20230528/58178a7e26874659b15153158732cd54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjEzOTMx_size_16_color_FFFFFF_t_70 2]: /images/20230528/891a215f613344dbb19374bbfa0fb9dd.png
[20200325132528589.png]: /images/20230528/d959b6f8df5c42e999208f6a66858aa9.png
[2020032513255582.png]: /images/20230528/c307416a118c4db4819852ddc57fa7fa.png
[20200325132656863.png]: /images/20230528/7f026954f2df47f7b97d309935e8b3a5.png
[20200325132730786.png]: /images/20230528/2086159f05e0486aa0249c1bf747f1de.png
[20200325132748254.png]: /images/20230528/1ae4f359e7b34825a151e4a4ffb1a186.png
[2020032513283769.png]: /images/20230528/b3351118cdff482ea6b1f0669b4e2999.png
[20200325132918677.png]: /images/20230528/f0769b579d844d6296e02f76f4fe9729.png
[20200325133220692.png]: /images/20230528/e2abf2bd9aa94acc8928a781e353c2a1.png
[20200325133252764.png]: /images/20230528/243fff984e7e4664ad2c27ecd259c215.png
[20200325133312236.png]: /images/20230528/ce8b03dfd38d4f53bd49f38bdabb6c22.png
[20200325133332671.png]: /images/20230528/f3bb508bc24443b18096e688fd32f772.png
[20200325133428476.png]: /images/20230528/7208501a047b456d98e9a931cb2ff997.png