mirror of
https://github.com/chefyuan/algorithm-base.git
synced 2026-03-10 20:04:44 +00:00
test
This commit is contained in:
chefyuan
@@ -0,0 +1,130 @@
|
||||
> 为保证代码严谨性，文中所有代码均在 leetcode 刷题网站 AC ，大家可以放心食用。
|
||||
|
||||
皇上生辰之际，举国同庆，袁记菜馆作为天下第一饭店，所以被选为这次庆典的菜品供应方，这次庆典对于袁记菜馆是一项前所未有的挑战，毕竟是第一次给皇上庆祝生辰，稍有不慎就是掉脑袋的大罪，整个袁记菜馆内都在紧张的布置着。此时突然有一个店小二慌慌张张跑到袁厨面前汇报，到底发生了什么事，让店小二如此慌张呢？
|
||||
|
||||
袁记菜馆内
|
||||
|
||||
店小二：不好了不好了，掌柜的，出大事了。
|
||||
|
||||
袁厨：发生什么事了，慢慢说，如此慌张，成何体统。（开店开久了，架子出来了哈）
|
||||
|
||||
店小二：皇上按照咱们菜单点了 666 道菜，但是咱们做西湖醋鱼的师傅请假回家结婚了，不知道皇上有没有点这道菜，如果点了这道菜，咱们做不出来，那咱们店可就完了啊。
|
||||
|
||||
（袁厨听了之后，吓得一屁股坐地上了，缓了半天说道）
|
||||
|
||||
袁厨：别说那么多了，快给我找找皇上点的菜里面，有没有这道菜！
|
||||
|
||||
找了很久，并且核对了很多遍，最后确认皇上没有点这道菜。菜馆内的人都松了一口气
|
||||
|
||||
通过上面的一个例子，让我们简单了解了字符串匹配。
|
||||
|
||||
字符串匹配：设 S 和 T 是给定的两个串，在主串 S 中找到模式串 T 的过程称为字符串匹配，如果在主串 S 中找到 模式串 T ，则称匹配成功，函数返回 T 在 S 中首次出现的位置，否则匹配不成功，返回 -1。
|
||||
|
||||
例：
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
在上图中，我们试图找到模式 T = baab,在主串 S = abcabaabcabac 中第一次出现的位置，即为红色阴影部分， T 第一次在 S 中出现的位置下标为 4 （ 字符串的首位下标是 0 ），所以返回 4。如果模式串 T 没有在主串 S 中出现，则返回 -1。
|
||||
|
||||
解决上面问题的算法我们称之为字符串匹配算法，今天我们来介绍三种字符串匹配算法，大家记得打卡呀，说不准面试的时候就问到啦。
|
||||
|
||||
## BF算法（Brute Force）
|
||||
|
||||
这个算法很容易理解，就是我们将模式串和主串进行比较，一致时则继续比较下一字符，直到比较完整个模式串。不一致时则将模式串后移一位，重新从模式串的首位开始对比，重复刚才的步骤下面我们看下这个方法的动图解析，看完肯定一下就能搞懂啦。
|
||||
|
||||
|
||||
|
||||
**因为不可以放置视频，所以想看视频的同学，可以去看公众号原文，那里有视频**
|
||||
|
||||
通过上面的代码是不是一下就将这个算法搞懂啦，下面我们用这个算法来解决下面这个经典题目吧。
|
||||
|
||||
### leetcdoe 28. 实现 strStr()
|
||||
|
||||
#### 题目描述
|
||||
|
||||
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
|
||||
|
||||
示例 1:
|
||||
|
||||
> 输入: haystack = "hello", needle = "ll"
|
||||
> 输出: 2
|
||||
|
||||
示例 2:
|
||||
|
||||
> 输入: haystack = "aaaaa", needle = "bba"
|
||||
> 输出: -1
|
||||
|
||||
#### 题目解析
|
||||
|
||||
其实这个题目很容易理解，但是我们需要注意的是一下几点，比如我们的模式串为 0 时，应该返回什么，我们的模式串长度大于主串长度时，应该返回什么，也是我们需要注意的地方。下面我们来看一下题目代码吧。
|
||||
|
||||
#### 题目代码
|
||||
|
||||
```java
|
||||
class Solution {
|
||||
public int strStr(String haystack, String needle) {
|
||||
int haylen = haystack.length();
|
||||
int needlen = needle.length();
|
||||
//特殊情况
|
||||
if (haylen < needlen) {
|
||||
return -1;
|
||||
}
|
||||
if (needlen == 0) {
|
||||
return 0;
|
||||
}
|
||||
//主串
|
||||
for (int i = 0; i < haylen - needlen + 1; ++i) {
|
||||
int j;
|
||||
//模式串
|
||||
for (j = 0; j < needlen; j++) {
|
||||
//不符合的情况，直接跳出，主串指针后移一位
|
||||
if (haystack.charAt(i+j) != needle.charAt(j)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
//匹配成功
|
||||
if (j == needlen) {
|
||||
return i;
|
||||
}
|
||||
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
我们看一下BF算法的另一种算法（显示回退），其实原理一样，就是对代码进行了一下修改，只要是看完咱们的动图，这个也能够一下就能看懂，大家可以结合下面代码中的注释和动图进行理解。
|
||||
|
||||
```java
|
||||
class Solution {
|
||||
public int strStr(String haystack, String needle) {
|
||||
//i代表主串指针，j模式串
|
||||
int i,j;
|
||||
//主串长度和模式串长度
|
||||
int halen = haystack.length();
|
||||
int nelen = needle.length();
|
||||
//循环条件，这里只有 i 增长
|
||||
for (i = 0 , j = 0; i < halen && j < nelen; ++i) {
|
||||
//相同时，则移动 j 指针
|
||||
if (haystack.charAt(i) == needle.charAt(j)) {
|
||||
++j;
|
||||
} else {
|
||||
//不匹配时，将 j 重新指向模式串的头部，将 i 本次匹配的开始位置的下一字符
|
||||
i -= j;
|
||||
j = 0;
|
||||
}
|
||||
}
|
||||
//查询成功时返回索引，查询失败时返回 -1；
|
||||
int renum = j == nelen ? i - nelen : -1;
|
||||
return renum;
|
||||
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
@@ -0,0 +1,214 @@
|
||||
## BM算法(Boyer-Moore)
|
||||
|
||||
我们刚才说过了 BF 算法，但是 BF 算法是有缺陷的，比如我们下面这种情况
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
如上图所示，如果我们利用 BF 算法，遇到不匹配字符时，每次右移一位模式串，再重新从头进行匹配，我们观察一下，我们的模式串 abcdex 中每个字符都不一样，但是我们第一次进行字符串匹配时，abcde 都匹配成功，到 x 时失败，又因为模式串每位都不相同，所以我们不需要再每次右移一位，再重新比较，我们可以直接跳过某些步骤。如下图
|
||||
|
||||
|
||||
|
||||
我们可以跳过其中某些步骤，直接到下面这个步骤。那我们是依据什么原则呢？
|
||||
|
||||
|
||||
|
||||
### 坏字符规则
|
||||
|
||||
我们之前的 BF 算法是从前往后进行比较 ，BM 算法是从后往前进行比较，我们来看一下具体过程，我们还是利用上面的例子。
|
||||
|
||||
|
||||
|
||||
BM 算法是从后往前进行比较，此时我们发现比较的第一个字符就不匹配，我们将**主串**这个字符称之为**坏字符**，也就是 f ,我们发现坏字符之后，模式串 T 中查找是否含有该字符（f），我们发现并不存在 f，此时我们只需将模式串右移到坏字符的后面一位即可。如下图
|
||||
|
||||
|
||||
|
||||
那我们在模式串中找到坏字符该怎么办呢？
|
||||
|
||||
|
||||
|
||||
此时我们的坏字符为 f ,我们在模式串中，查找发现含有坏字符 f,我们则需要移动模式串 T ,将模式串中的 f 和坏字符对齐。见下图。
|
||||
|
||||
|
||||
|
||||
然后我们继续从右往左进行比较，发现 d 为坏字符，则需要将模式串中的 d 和坏字符对齐。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
那么我们在来思考一下这种情况，那就是模式串中含有多个坏字符怎么办呢？
|
||||
|
||||
|
||||
|
||||
那么我们为什么要让**最靠右的对应元素与坏字符匹配**呢？如果上面的例子我们没有按照这条规则看下会产生什么问题。
|
||||
|
||||
|
||||
|
||||
如果没有按照我们上述规则，则会**漏掉我们的真正匹配**。我们的主串中是**含有 babac** 的，但是却**没有匹配成功**，所以应该遵守**最靠右的对应字符与坏字符相对**的规则。
|
||||
|
||||
我们上面一共介绍了三种移动情况，分别是下方的模式串中没有发现与坏字符对应的字符，发现一个对应字符，发现两个。这三种情况我们分别移动不同的位数，那我们是根据依据什么来决定移动位数的呢？下面我们给图中的字符加上下标。见下图
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
下面我们来考虑一下这种情况。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
此时这种情况肯定是不行的，不往右移动，甚至还有可能左移，那么我们有没有什么办法解决这个问题呢？继续往下看吧。
|
||||
|
||||
### 好后缀规则
|
||||
|
||||
好后缀其实也很容易理解，我们之前说过 BM 算法是从右往左进行比较，下面我们来看下面这个例子。
|
||||
|
||||
|
||||
|
||||
这里如果我们按照坏字符进行移动是不合理的，这时我们可以使用好后缀规则，那么什么是好后缀呢？
|
||||
|
||||
BM 算法是从右往左进行比较，发现坏字符的时候此时 cac 已经匹配成功，在红色阴影处发现坏字符。此时已经匹配成功的 cac 则为我们的好后缀，此时我们拿它在模式串中查找，如果找到了另一个和好后缀相匹配的串，那我们就将另一个和**好后缀相匹配**的串 ，滑到和好后缀对齐的位置。
|
||||
|
||||
是不是感觉有点拗口，没关系，我们看下图，红色代表坏字符，绿色代表好后缀
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
上面那种情况搞懂了，但是我们思考一下下面这种情况
|
||||
|
||||
|
||||
|
||||
上面我们说到了，如果在模式串的**头部**没有发现好后缀，发现好后缀的子串也可以。但是为什么要强调这个头部呢？
|
||||
|
||||
我们下面来看一下这种情况
|
||||
|
||||
|
||||
|
||||
但是当我们在头部发现好后缀的子串时，是什么情况呢？
|
||||
|
||||
|
||||
|
||||
下面我们通过动图来看一下某一例子的具体的执行过程
|
||||
|
||||
|
||||
|
||||
说到这里，坏字符和好后缀规则就算说完了，坏字符很容易理解，我们对好后缀总结一下
|
||||
|
||||
1.如果模式串**含有好后缀**，无论是中间还是头部可以按照规则进行移动。如果好后缀在模式串中出现多次，则以**最右侧的好后缀**为基准。
|
||||
|
||||
2.如果模式串**头部含有**好后缀子串则可以按照规则进行移动，中间部分含有好后缀子串则不可以。
|
||||
|
||||
3.如果在模式串尾部就出现不匹配的情况，即不存在好后缀时，则根据坏字符进行移动，这里有的文章没有提到，是个需要特别注意的地方，我是在这个论文里找到答案的，感兴趣的同学可以看下。
|
||||
|
||||
> Boyer R S，Moore J S. A fast string searching algorithm［J］. Communications of the ACM，1977，10： 762-772.
|
||||
|
||||
|
||||
|
||||
之前我们刚开始说坏字符的时候，是不是有可能会出现负值的情况，即往左移动的情况，所以我们为了解决这个问题，我们可以分别计算好后缀和坏字符往后滑动的位数**（好后缀不为 0 的情况）**，然后取两个数中最大的，作为模式串往后滑动的位数。
|
||||
|
||||
|
||||
|
||||
这破图画起来是真费劲啊。下面我们来看一下算法代码，代码有点长，我都标上了注释也在网站上 AC 了，如果各位感兴趣可以看一下，不感兴趣理解坏字符和好后缀规则即可。可以直接跳到 KMP 部分
|
||||
|
||||
```java
|
||||
class Solution {
|
||||
public int strStr(String haystack, String needle) {
|
||||
char[] hay = haystack.toCharArray();
|
||||
char[] need = needle.toCharArray();
|
||||
int haylen = haystack.length();
|
||||
int needlen = need.length;
|
||||
return bm(hay,haylen,need,needlen);
|
||||
}
|
||||
//用来求坏字符情况下移动位数
|
||||
private static void badChar(char[] b, int m, int[] bc) {
|
||||
//初始化
|
||||
for (int i = 0; i < 256; ++i) {
|
||||
bc[i] = -1;
|
||||
}
|
||||
//m 代表模式串的长度，如果有两个 a,则后面那个会覆盖前面那个
|
||||
for (int i = 0; i < m; ++i) {
|
||||
int ascii = (int)b[i];
|
||||
bc[ascii] = i;//下标
|
||||
}
|
||||
}
|
||||
//用来求好后缀条件下的移动位数
|
||||
private static void goodSuffix (char[] b, int m, int[] suffix,boolean[] prefix) {
|
||||
//初始化
|
||||
for (int i = 0; i < m; ++i) {
|
||||
suffix[i] = -1;
|
||||
prefix[i] = false;
|
||||
}
|
||||
for (int i = 0; i < m - 1; ++i) {
|
||||
int j = i;
|
||||
int k = 0;
|
||||
while (j >= 0 && b[j] == b[m-1-k]) {
|
||||
--j;
|
||||
++k;
|
||||
suffix[k] = j + 1;
|
||||
}
|
||||
if (j == -1) prefix[k] = true;
|
||||
}
|
||||
}
|
||||
public static int bm (char[] a, int n, char[] b, int m) {
|
||||
|
||||
int[] bc = new int[256];//创建一个数组用来保存最右边字符的下标
|
||||
badChar(b,m,bc);
|
||||
//用来保存各种长度好后缀的最右位置的数组
|
||||
int[] suffix_index = new int[m];
|
||||
//判断是否是头部，如果是头部则true
|
||||
boolean[] ispre = new boolean[m];
|
||||
goodSuffix(b,m,suffix_index,ispre);
|
||||
int i = 0;//第一个匹配字符
|
||||
//注意结束条件
|
||||
while (i <= n-m) {
|
||||
int j;
|
||||
//从后往前匹配，匹配失败，找到坏字符
|
||||
for (j = m - 1; j >= 0; --j) {
|
||||
if (a[i+j] != b[j]) break;
|
||||
}
|
||||
//模式串遍历完毕，匹配成功
|
||||
if (j < 0) {
|
||||
return i;
|
||||
}
|
||||
//下面为匹配失败时，如何处理
|
||||
//求出坏字符规则下移动的位数，就是我们坏字符下标减最右边的下标
|
||||
int x = j - bc[(int)a[i+j]];
|
||||
int y = 0;
|
||||
//好后缀情况，求出好后缀情况下的移动位数,如果不含有好后缀的话，则按照坏字符来
|
||||
if (y < m-1 && m - 1 - j > 0) {
|
||||
y = move(j, m, suffix_index,ispre);
|
||||
}
|
||||
//移动
|
||||
i = i + Math.max(x,y);
|
||||
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
// j代表坏字符的下标
|
||||
private static int move (int j, int m, int[] suffix_index, boolean[] ispre) {
|
||||
//好后缀长度
|
||||
int k = m - 1 - j;
|
||||
//如果含有长度为 k 的好后缀，返回移动位数，
|
||||
if (suffix_index[k] != -1) return j - suffix_index[k] + 1;
|
||||
//找头部为好后缀子串的最大长度，从长度最大的子串开始
|
||||
for (int r = j + 2; r <= m-1; ++r) {
|
||||
//如果是头部
|
||||
if (ispre[m-r] == true) {
|
||||
return r;
|
||||
}
|
||||
}
|
||||
//如果没有发现好后缀匹配的串，或者头部为好后缀子串，则移动到 m 位，也就是匹配串的长度
|
||||
return m;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
我们来理解一下我们代码中用到的两个数组，因为两个规则的移动位数，只与模式串有关，与主串无关，所以我们可以提前求出每种情况的移动情况，保存到数组中。
|
||||
|
||||
|
||||
363
gif-algorithm/数据结构和算法/Hash表的那些事.md
Normal file
363
gif-algorithm/数据结构和算法/Hash表的那些事.md
Normal file
@@ -0,0 +1,363 @@
|
||||
# 散列（哈希）表总结
|
||||
|
||||
之前给大家介绍了**链表**，**栈和队列**今天我们来说一种新的数据结构散列（哈希）表，散列是应用非常广泛的数据结构，在我们的刷题过程中，散列表的出场率特别高。所以我们快来一起把散列表的内些事给整明白吧。文章框架如下
|
||||
|
||||
|
||||
|
||||
说散列表之前，我们先设想以下场景。
|
||||
|
||||
> 袁厨穿越回了古代，凭借从现代学习的做饭手艺，开了一个袁记菜馆，正值开业初期，店里生意十分火爆，但是顾客结账时就犯难了，每当结账的时候，老板娘总是按照菜单一个一个找价格（遍历查找），每次都要找半天，所以结账的地方总是排起长队，顾客们表示用户体验不咋滴。袁厨一想这不是办法啊，让顾客老是等着，太影响客户体验啦。所以袁厨就先把菜单按照首字母排序（二分查找），然后查找的时候根据首字母查找，这样结账的时候就能大大提高检索效率啦！但是呢？工作日顾客不多，老板娘完全应付的过来，但是每逢节假日，还是会排起长队。那么有没有什么更好的办法呢？对呀！我们把所有的价格都背下来不就可以了吗？每个菜的价格我们都了如指掌，结账的时候我们只需简单相加即可。所以袁厨和老板娘加班加点的进行背诵。下次再结账的时候一说吃了什么菜，我们立马就知道价格啦。自此以后收银台再也没有出现过长队啦，袁记菜馆开着开着一不小心就成了天下第一饭店了。
|
||||
|
||||
下面我们来看一下袁记菜馆老板娘进化史。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
上面的后期结账的过程则模拟了我们的散列表查找，那么在计算机中是如何使用进行查找的呢？
|
||||
|
||||
### 散列表查找步骤
|
||||
|
||||
散列表-------最有用的基本数据结构之一。是根据关键码的值儿直接进行访问的数据结构，散列表的实现常常叫做**散列（hasing）**。散列是一种用于以**常数平均时间**执行插入、删除和查找的技术，下面我们来看一下散列过程。
|
||||
|
||||
我们的整个散列过程主要分为两步
|
||||
|
||||
（1）通过**散列函数**计算记录的散列地址，并按此**散列地址**存储该记录。就好比麻辣鱼我们就让它在川菜区，糖醋鱼，我们就让它在鲁菜区。但是我们需要注意的是，无论什么记录我们都需要用**同一个散列函数**计算地址，再存储。
|
||||
|
||||
（2)当我们查找时，我们通过**同样的散列函数**计算记录的散列地址，按此散列地址访问该记录。因为我们存和取得时候用的都是一个散列函数，因此结果肯定相同。
|
||||
|
||||
刚才我们在散列过程中提到了散列函数，那么散列函数是什么呢？
|
||||
|
||||
我们假设某个函数为 **f**，使得
|
||||
|
||||
**存储位置 = f (关键字)**
|
||||
|
||||
**输入：关键字** **输出：存储位置(散列地址)**
|
||||
|
||||
那样我们就能通过查找关键字**不需要比较**就可获得需要的记录的存储位置。这种存储技术被称为散列技术。散列技术是在通过记录的存储位置和它的关键字之间建立一个确定的对应关系 **f** ,使得每个关键字 **key** 都对应一个存储位置 **f(key)**。见下图
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
这里的 **f** 就是我们所说的散列函数（哈希）函数。我们利用散列技术将记录存储在一块连续的存储空间中，这块连续存储空间就是我们本文的主人公------**散列(哈希)表**
|
||||
|
||||
上图为我们描述了用散列函数将关键字映射到散列表，但是大家有没有考虑到这种情况，那就是将关键字映射到同一个槽中的情况，即 **f(k4) = f(k3)** 时。这种情况我们将其称之为**冲突**，**k3** 和 **k4**则被称之为散列函数 **f** 的**同义词**，如果产生这种情况，则会让我们查找错误。幸运的是我们能找到有效的方法解决冲突。
|
||||
|
||||
首先我们可以对哈希函数下手，我们可以精心设计哈希函数，让其尽可能少的产生冲突，所以我们创建哈希函数时应遵循以下规则
|
||||
|
||||
（1）**必须是一致的**，假设你输入辣子鸡丁时得到的是**在看**，那么每次输入辣子鸡丁时，得到的也必须为**在看**。如果不是这样，散列表将毫无用处。
|
||||
|
||||
（2）**计算简单**，假设我们设计了一个算法，可以保证所有关键字都不会冲突，但是这个算法计算复杂，会耗费很多时间，这样的话就大大降低了查找效率，反而得不偿失。所以咱们**散列函数的计算时间不应该超过其他查找技术与关键字的比较时间**，不然的话我们干嘛不使用其他查找技术呢?
|
||||
|
||||
（3）**散列地址分布均匀**我们刚才说了冲突的带来的问题，所以我们最好的办法就是让**散列地址尽量均匀分布在存储空间中**，这样即保证空间的有效利用，又减少了处理冲突而消耗的时间。
|
||||
|
||||
现在我们已经对散列表，散列函数等知识有所了解啦，那么我们来看几种常用的散列函数构造规则。这些方法的共同点为都是将原来的数字按某种规律变成了另一个数字。
|
||||
|
||||
### 散列函数构造方法
|
||||
|
||||
#### 直接定址法
|
||||
|
||||
如果我们对盈利为0-9的菜品设计哈希表，我们则直接可以根据作为地址，则 **f(key) = key**;
|
||||
|
||||
即下面这种情况。
|
||||
|
||||
|
||||
|
||||
有没有感觉上面的图很熟悉，没错我们经常用的数组其实就是一张哈希表，关键码就是数组的索引下标，然后我们通过下标直接访问数组中的元素。
|
||||
|
||||
另外我们假设每道菜的成本为50块，那我们还可以根据盈利+成本来作为地址，那么则 f(key) = key + 50。也就是说我们可以根据线性函数值作为散列地址。
|
||||
|
||||
**f(key) = a * key + b** **a,b均为常数**
|
||||
|
||||
优点：简单、均匀、无冲突。
|
||||
|
||||
应用场景：需要事先知道关键字的分布情况，适合查找表较小且连续的情况
|
||||
|
||||
#### 数字分析法
|
||||
|
||||
该方法也是十分简单的方法，就是分析我们的关键字，取其中一段，或对其位移，叠加，用作地址。比如我们的学号，前 6 位都是一样的，但是后面 3 位都不相同，我们则可以用学号作为键，后面的 3 位做为我们的散列地址。如果我们这样还是容易产生冲突，则可以对抽取数字再进行处理。我们的目的只有一个，提供一个散列函数将关键字合理的分配到散列表的各位置。这里我们提到了一种新的方式，抽取，这也是在散列函数中经常用到的手段。
|
||||
|
||||
|
||||
|
||||
优点：简单、均匀、适用于关键字位数较大的情况
|
||||
|
||||
应用场景：关键字位数较大，知道关键字分布情况且关键字的若干位较均匀
|
||||
|
||||
#### 折叠法
|
||||
|
||||
其实这个方法也很简单，也是处理我们的关键字然后用作我们的散列地址，主要思路是将关键字从左到右分割成位数相等的几部分，然后叠加求和，并按散列表表长，取后几位作为散列地址。
|
||||
|
||||
比如我们的关键字是123456789，则我们分为三部分 123 ，456 ，789 然后将其相加得 1368 然后我们再取其后三位 368 作为我们的散列地址。
|
||||
|
||||
优点：事先不需要知道关键字情况
|
||||
|
||||
应用场景：适合关键字位数较多的情况
|
||||
|
||||
#### 除法散列法
|
||||
|
||||
在用来设计散列函数的除法散列法中，通过取 key 除以 p 的余数，将关键字映射到 p 个槽中的某一个上，对于散列表长度为 m 的散列函数公式为
|
||||
|
||||
**f(k) = k mod p (p <= m)**
|
||||
|
||||
例如，如果散列表长度为 12，即 m = 12 ，我们的参数 p 也设为12，**那 k = 100时 f(k) = 100 % 12 = 4**
|
||||
|
||||
由于只需要做一次除法操作，所以除法散列法是非常快的。
|
||||
|
||||
由上面的公式可以看出，该方法的重点在于 p 的取值，如果 p 值选的不好，就可能会容易产生同义词。见下面这种情况。我们哈希表长度为6，我们选择6为p值，则有可能产生这种情况，所有关键字都得到了0这个地址数。
|
||||
|
||||
那我们在选用除法散列法时选取 p 值时应该遵循怎样的规则呢？
|
||||
|
||||
- m 不应为 2 的幂，因为如果 m = 2^p ，则 f(k) 就是 k 的 p 个最低位数字。例 12 % 8 = 4 ，12的二进制表示位1100，后三位为100。
|
||||
- 若散列表长为 m ,通常 p 为 小于或等于表长（最好接近m）的最小质数或不包含小于 20 质因子的合数。
|
||||
|
||||
> **合数：**合数是指在大于1的整数中除了能被1和本身整除外，还能被其他数（0除外）整除的数。
|
||||
>
|
||||
> **质因子**：质因子（或质因数）在数论里是指能整除给定正整数的质数。
|
||||
|
||||
|
||||
|
||||
这里的2，3，5为质因子
|
||||
|
||||
还是上面的例子，我们根据规则选择 5 为 p 值，我们再来看。这时我们发现只有 6 和 36 冲突，相对来说就好了很多。
|
||||
|
||||
|
||||
|
||||
优点：计算效率高，灵活
|
||||
|
||||
应用场景：不知道关键字分布情况
|
||||
|
||||
#### 乘法散列法
|
||||
|
||||
构造散列函数的乘法散列法主要包含两个步骤
|
||||
|
||||
- 用关键字 k 乘上常数 A(0 < A < 1)，并提取 k A 的小数部分
|
||||
- 用 m 乘以这个值，再向下取整
|
||||
|
||||
散列函数为
|
||||
|
||||
**f (k) = ⌊ m(kA mod 1) ⌋**
|
||||
|
||||
这里的 **kA mod 1** 的含义是取 keyA 的小数部分，即 **kA - ⌊kA⌋** 。
|
||||
|
||||
优点：对 m 的选择不是特别关键，一般选择它为 2 的某个幂次（m = 2 ^ p ,p为某个整数）
|
||||
|
||||
应用场景：不知道关键字情况
|
||||
|
||||
#### 平方取中法
|
||||
|
||||
这个方法就比较简单了，假设关键字是 321，那么他的平方就是 103041，再抽取中间的 3 位就是 030 或 304 用作散列地址。再比如关键字是 1234 那么它的平方就是 1522756 ，抽取中间 3 位就是 227 用作散列地址.
|
||||
|
||||
优点：灵活，适用范围广泛
|
||||
|
||||
适用场景：不知道关键字分布，而位数又不是很大的情况。
|
||||
|
||||
#### 随机数法
|
||||
|
||||
故名思意，取关键字的随机函数值为它的散列地址。也就是 **f(key) = random(key)**。这里的random是 随机函数。
|
||||
|
||||
优点：易实现
|
||||
|
||||
适用场景：关键字的长度不等时
|
||||
|
||||
上面我们的例子都是通过数字进行举例，那么如果是字符串可不可以作为键呢？当然也是可以的，各种各样的符号我们都可以转换成某种数字来对待，比如我们经常接触的ASCII 码，所以是同样适用的。
|
||||
|
||||
以上就是常用的散列函数构造方法，其实他们的中心思想是一致的，将关键字经过加工处理之后变成另外一个数字，而这个数字就是我们的存储位置，是不是有一种间谍传递情报的感觉。
|
||||
|
||||
一个好的哈希函数可以帮助我们尽可能少的产生冲突，但是也不能完全避免产生冲突，那么遇到冲突时应该怎么做呢？下面给大家带来几种常用的处理散列冲突的方法。
|
||||
|
||||
### 处理散列冲突的方法
|
||||
|
||||
我们在使用 hash 函数之后发现关键字 key1 不等于 key2 ，但是 f(key1) = f(key2)，即有冲突，那么该怎么办呢？不急我们慢慢往下看。
|
||||
|
||||
#### 开放地址法
|
||||
|
||||
了解开放地址法之前我们先设想以下场景。
|
||||
|
||||
> 袁记菜馆内，铃铃铃，铃铃铃 电话铃响了
|
||||
>
|
||||
> 大鹏：老袁，给我订个包间，我今天要去带几个客户去你那谈生意。
|
||||
>
|
||||
> 袁厨：大鹏啊，你常用的那个包间被人订走啦。
|
||||
>
|
||||
> 大鹏：老袁你这不仗义呀，咋没给我留住呀，那你给我找个**空房间**吧。
|
||||
>
|
||||
> 袁厨：好滴老哥
|
||||
|
||||
哦，穿越回古代就没有电话啦，那看来穿越的时候得带着几个手机了。
|
||||
|
||||
上面的场景其实就是一种处理冲突的方法-----开放地址法
|
||||
|
||||
**开放地址法**就是一旦发生冲突，就去寻找下一个空的散列地址，只要列表足够大，空的散列地址总能找到，并将记录存入，为了使用开放寻址法插入一个元素，需要连续地检查散列表，或称为**探查**，我们常用的有**线性探测，二次探测，随机探测**。
|
||||
|
||||
##### 线性探测法
|
||||
|
||||
下面我们先来看一下线性探测，公式：
|
||||
|
||||
> **f,(key) = ( f(key) + di ) MOD m（di = 1,2,3,4,5,6....m-1）**
|
||||
|
||||
我们来看一个例子，我们的关键字集合为{12，67，56，16，25，37，22，29，15，47，48，21}，表长为12，我们再用散列函数 **f(key) = key mod 12。**
|
||||
|
||||
我们求出每个 key 的 f(key)见下表
|
||||
|
||||
|
||||
|
||||
我们查看上表发现，前五位的 **f(key)** 都不相同，即没有冲突，可以直接存入，但是到了第六位 **f(37) = f(25) = 1**,那我们就需要利用上面的公式 **f(37) = f (f(37) + 1 ) mod 12 = 2**，这其实就是我们的订包间的做法。下面我们看一下将上面的所有数存入哈希表是什么情况吧。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
我们把这种解决冲突的开放地址法称为**线性探测法**。下面我们通过视频来模拟一下线性探测法的存储过程。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
另外我们在解决冲突的时候，会遇到 48 和 37 虽然不是同义词，却争夺一个地址的情况，我们称其为**堆积**。因为堆积使得我们需要不断的处理冲突，插入和查找效率都会大大降低。
|
||||
|
||||
通过上面的视频我们应该了解了线性探测的执行过程了，那么我们考虑一下这种情况，若是我们的最后一位不为21，为 34 时会有什么事情发生呢？
|
||||
|
||||
|
||||
|
||||
此时他第一次会落在下标为 10 的位置，那么如果继续使用线性探测的话，则需要通过不断取余后得到结果，数据量小还好，要是很大的话那也太慢了吧，但是明明他的前面就有一个空房间呀，如果向前移动只需移动一次即可。不要着急，前辈们已经帮我们想好了解决方法
|
||||
|
||||
##### 二次探测法
|
||||
|
||||
其实理解了我们的上个例子之后，这个一下就能整明白了，根本不用费脑子，这个方法就是更改了一下di的取值
|
||||
|
||||
> **线性探测： f,(key) = ( f(key) + di ) MOD m（di = 1,2,3,4,5,6....m-1）**
|
||||
>
|
||||
> **二次探测：** **f,(key) = ( f(key) + di ) MOD m（di =1^2 , -1^2 , 2^2 , -2^2 .... q^2, -q^2, q<=m/2）**
|
||||
|
||||
**注：这里的是 -1^2 为负值 而不是 （-1)^2**
|
||||
|
||||
所以对于我们的34来说，当di = -1时，就可以找到空位置了。
|
||||
|
||||
|
||||
|
||||
二次探测法的目的就是为了不让关键字聚集在某一块区域。另外还有一种有趣的方法，位移量采用随机函数计算得到，接着往下看吧.
|
||||
|
||||
##### 随机探测法
|
||||
|
||||
大家看到这是不又有新问题了，刚才我们在散列函数构造规则的第一条中说
|
||||
|
||||
> （1）**必须是一致的**，假设你输入辣子鸡丁时得到的是**在看**，那么每次输入辣子鸡丁时，得到的也必须为**在看**。如果不是这样，散列表将毫无用处。
|
||||
|
||||
咦？怎么又是**在看**哈哈，那么问题来了，我们使用随机数作为他的偏移量，那么我们查找的时候岂不是查不到了？因为我们 di 是随机生成的呀，这里的随机其实是伪随机数，伪随机数含义为，我们设置**随机种子**相同，则不断调用随机函数可以生成**不会重复的数列**，我们在查找时，**用同样的随机种子**，**它每次得到的数列是相同的**，那么相同的 di 就能得到**相同的散列地址**。
|
||||
|
||||
> 随机种子（Random Seed）是计算机专业术语，一种以随机数作为对象的以真随机数（种子）为初始条件的随机数。一般计算机的随机数都是伪随机数，以一个真随机数（种子）作为初始条件，然后用一定的算法不停迭代产生随机数
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
通过上面的测试是不是一下就秒懂啦，为什么我们可以使用随机数作为它的偏移量，理解那句，相同的随机种子，他每次得到的数列是相同的。
|
||||
|
||||
下面我们再来看一下其他的函数处理散列冲突的方法
|
||||
|
||||
#### 再哈希法
|
||||
|
||||
这个方法其实也特别简单，利用不同的哈希函数再求得一个哈希地址，直到不出现冲突为止。
|
||||
|
||||
> **f,(key) = RH,( key ) (i = 1,2,3,4.....k)**
|
||||
|
||||
这里的RH,就是不同的散列函数，你可以把我们之前说过的那些散列函数都用上，每当发生冲突时就换一个散列函数，相信总有一个能够解决冲突的。这种方法能使关键字不产生聚集，但是代价就是增加了计算时间。是不是很简单啊。
|
||||
|
||||
#### 链地址法
|
||||
|
||||
下面我们再设想以下情景。
|
||||
|
||||
> 袁记菜馆内，铃铃铃，铃铃铃电话铃又响了，那个大鹏又来订房间了。
|
||||
>
|
||||
> 大鹏：老袁啊，我一会去你那吃个饭，还是上回那个包间
|
||||
>
|
||||
> 袁厨：大鹏你下回能不能早点说啊，又没人订走了，这回是老王订的
|
||||
>
|
||||
> 大鹏：老王这个老东西啊，反正也是熟人，你再给我整个桌子，我拼在他后面吧
|
||||
|
||||
不好意思啊各位同学，信鸽最近太贵了还没来得及买。上面的情景就是模拟我们的新的处理冲突的方法链地址法。
|
||||
|
||||
上面我们都是遇到冲突之后，就换地方。那么我们有没有不换地方的办法呢？那就是我们现在说的链地址法。
|
||||
|
||||
还记得我们说过得同义词吗？就是 key 不同 f(key) 相同的情况，我们将这些同义词存储在一个单链表中，这种表叫做同义词子表，散列表中只存储同义词子表的头指针。我们还是用刚才的例子，关键字集合为{12，67，56，16，25，37，22，29，15，47，48，21}，表长为12，我们再用散列函数 **f(key) = key mod 12。**我们用了链地址法之后就再也不存在冲突了，无论有多少冲突，我们只需在同义词子表中添加结点即可。下面我们看下链地址法的存储情况。
|
||||
|
||||
|
||||
|
||||
链地址法虽然能够不产生冲突，但是也带来了查找时需要遍历单链表的性能消耗，有得必有失嘛。
|
||||
|
||||
|
||||
|
||||
#### 公共溢出区法
|
||||
|
||||
下面我们再来看一种新的方法，这回大鹏又要来吃饭了。
|
||||
|
||||
> 袁记菜馆内.....
|
||||
>
|
||||
> 袁厨：呦，这是什么风把你给刮来了，咋没开你的大奔啊。
|
||||
>
|
||||
> 大鹏：哎呀妈呀，别那么多废话了，我快饿死了，你快给我找个位置，我要吃点饭。
|
||||
>
|
||||
> 袁厨：你来的，太不巧了，咱们的店已经满了，你先去旁边的小屋看会电视，等有空了我再叫你。小屋里面还有几个和你一样来晚的，你们一起看吧。
|
||||
>
|
||||
> 大鹏：电视？看电视？
|
||||
|
||||
上面得情景就是模拟我们的公共溢出区法，这也是很好理解的，你不是冲突吗？那冲突的各位我先给你安排个地方呆着，这样你就有地方住了。我们为所有冲突的关键字建立了一个公共的溢出区来存放。
|
||||
|
||||
|
||||
|
||||
那么我们怎么进行查找呢？我们首先通过散列函数计算出散列地址后，先于基本表对比，如果不相等再到溢出表去顺序查找。这种解决冲突的方法，对于冲突很少的情况性能还是非常高的。
|
||||
|
||||
### 散列表查找算法(线性探测法)
|
||||
|
||||
下面我们来看一下散列表查找算法的实现
|
||||
|
||||
首先需要定义散列列表的结构以及一些相关常数，其中elem代表散列表数据存储数组，count代表的是当前插入元素个数，size代表哈希表容量，NULLKEY散列表初始值，然后我们如果查找成功就返回索引，如果不存在该元素就返回元素不存在。
|
||||
|
||||
我们将哈希表初始化，为数组元素赋初值。
|
||||
|
||||
|
||||
|
||||
插入操作的具体步骤：
|
||||
|
||||
（1）通过哈希函数（除法散列法），将 key 转化为数组下标
|
||||
|
||||
（2）如果该下标中没有元素，则插入，否则说明有冲突，则利用线性探测法处理冲突。详细步骤见注释
|
||||
|
||||
|
||||
|
||||
查找操作的具体步骤：
|
||||
|
||||
（1）通过哈希函数（同插入时一样），将 key 转成数组下标
|
||||
|
||||
（2）通过数组下标找到 key值，如果 key 一致，则查找成功，否则利用线性探测法继续查找。
|
||||
|
||||
|
||||
|
||||
下面我们来看一下完整代码
|
||||
|
||||
|
||||
|
||||
### 散列表性能分析
|
||||
|
||||
如果没有冲突的话，散列查找是我们查找中效率最高的，时间复杂度为O(1),但是没有冲突的情况是一种理想情况，那么散列查找的平均查找长度取决于哪些方面呢？
|
||||
|
||||
**1.散列函数是否均匀**
|
||||
|
||||
我们在上文说到，可以通过设计散列函数减少冲突，但是由于不同的散列函数对一组关键字产生冲突可能性是相同的，因此我们可以不考虑它对平均查找长度的影响。
|
||||
|
||||
**2.处理冲突的方法**
|
||||
|
||||
相同关键字，相同散列函数，不同处理冲突方式，会使平均查找长度不同，比如我们线性探测有时会堆积，则不如二次探测法好，因为链地址法处理冲突时不会产生任何堆积，因而具有最佳的平均查找性能
|
||||
|
||||
**3.散列表的装填因子**
|
||||
|
||||
本来想在上文中提到装填因子的，但是后来发现即使没有说明也不影响我们对哈希表的理解，下面我们来看一下装填因子的总结
|
||||
|
||||
> 装填因子 α = 填入表中的记录数 / 散列表长度
|
||||
|
||||
散列因子则代表着散列表的装满程度，表中记录越多，α就越大，产生冲突的概率就越大。我们上面提到的例子中 表的长度为12，填入记录数为6，那么此时的 α = 6 / 12 = 0.5 所以说当我们的 α 比较大时再填入元素那么产生冲突的可能性就非常大了。所以说散列表的平均查找长度取决于装填因子，而不是取决于记录数。所以说我们需要做的就是选择一个合适的装填因子以便将平均查找长度限定在一个范围之内。
|
||||
|
||||
> 各位如果能感觉到这个文章写的很用心的话，能给您带来一丢丢帮助的话，能麻烦您给这个文章点个赞吗？这样我就巨有动力写下去啦。
|
||||
|
||||
> 另外大家如果需要其他精选算法题的动图解析，大家可以微信关注下 【袁厨的算法小屋】，我是袁厨一个酷爱做饭所以自己考取了厨师证的菜鸡程序员，会一直用心写下去的，感谢支持！
|
||||
@@ -0,0 +1,123 @@
|
||||
## KMP算法（Knuth-Morris-Pratt）
|
||||
|
||||
我们刚才讲了 BM 算法，虽然不是特别容易理解，但是如果你用心看的话肯定可以看懂的，我们再来看一个新的算法，这个算法是考研时必考的算法。实际上 BM 和 KMP 算法的本质是一样的，你理解了 BM 再来理解 KMP 那就是分分钟的事啦。
|
||||
|
||||
我们先来看一个实例
|
||||
|
||||
|
||||
|
||||
为了让读者更容易理解，我们将指针移动改成了模式串移动，两者相对与主串的移动是一致的，重新比较时都是从指针位置继续比较。
|
||||
|
||||
通过上面的实例是不是很快就能理解 KMP 算法的思想了，但是 KMP 的难点不是在这里，不过多思考，认真看理解起来也是很轻松的。
|
||||
|
||||
在上面的例子中我们提到了一个名词，**最长公共前后缀**，这个是什么意思呢？下面我们通过一个较简单的例子进行描述。
|
||||
|
||||
|
||||
|
||||
此时我们在红色阴影处匹配失败，绿色为匹配成功部分，则我们观察匹配成功的部分。
|
||||
|
||||
我们来看一下匹配成功部分的所有前缀
|
||||
|
||||
|
||||
|
||||
我们的最长公共前后缀如下图，则我们需要这样移动
|
||||
|
||||
|
||||
|
||||
好啦，看完上面的图，KMP的核心原理已经基本搞定了，但是我们现在的问题是，我们应该怎么才能知道他的最长公共前后缀的长度是多少呢？怎么知道移动多少位呢？
|
||||
|
||||
刚才我们在 BM 中说到，我们移动位数跟主串无关，只跟模式串有关，跟我们的 bc,suffix,prefix 数组的值有关，我们通过这些数组就可以知道我们每次移动多少位啦，其实 KMP 也有一个数组，这个数组叫做 next 数组，那么这个 next 数组存的是什么呢？
|
||||
|
||||
next 数组存的咱们最长公共前后缀中，前缀的结尾字符下标。是不是感觉有点别扭，我们通过一个例子进行说明。
|
||||
|
||||
|
||||
|
||||
我们知道 next 数组之后，我们的 KMP 算法实现起来就很容易啦，另外我们看一下 next 数组到底是干什么用的。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
剩下的就不用说啦，完全一致啦，咱们将上面这个例子，翻译成和咱们开头对应的动画大家看一下。
|
||||
|
||||
|
||||
|
||||
下面我们看一下代码，标有详细注释，大家认真看呀。
|
||||
|
||||
**注：很多教科书的 next 数组表示方式不一致，理解即可**
|
||||
|
||||
```java
|
||||
class Solution {
|
||||
public int strStr(String haystack, String needle) {
|
||||
//两种特殊情况
|
||||
if (needle.length() == 0) {
|
||||
return 0;
|
||||
}
|
||||
if (haystack.length() == 0) {
|
||||
return -1;
|
||||
}
|
||||
// char 数组
|
||||
char[] hasyarr = haystack.toCharArray();
|
||||
char[] nearr = needle.toCharArray();
|
||||
//长度
|
||||
int halen = hasyarr.length;
|
||||
int nelen = nearr.length;
|
||||
//返回下标
|
||||
return kmp(hasyarr,halen,nearr,nelen);
|
||||
|
||||
}
|
||||
public int kmp (char[] hasyarr, int halen, char[] nearr, int nelen) {
|
||||
//获取next 数组
|
||||
int[] next = next(nearr,nelen);
|
||||
int j = 0;
|
||||
for (int i = 0; i < halen; ++i) {
|
||||
//发现不匹配的字符，然后根据 next 数组移动指针，移动到最大公共前后缀的，
|
||||
//前缀的后一位,和咱们移动模式串的含义相同
|
||||
while (j > 0 && hasyarr[i] != nearr[j]) {
|
||||
j = next[j - 1] + 1;
|
||||
//超出长度时，可以直接返回不存在
|
||||
if (nelen - j + i > halen) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
//如果相同就将指针同时后移一下，比较下个字符
|
||||
if (hasyarr[i] == nearr[j]) {
|
||||
++j;
|
||||
}
|
||||
//遍历完整个模式串，返回模式串的起点下标
|
||||
if (j == nelen) {
|
||||
return i - nelen + 1;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
//这一块比较难懂，不想看的同学可以忽略，了解大致含义即可，或者自己调试一下，看看运行情况
|
||||
//我会每一步都写上注释
|
||||
public int[] next (char[] needle,int len) {
|
||||
//定义 next 数组
|
||||
int[] next = new int[len];
|
||||
// 初始化
|
||||
next[0] = -1;
|
||||
int k = -1;
|
||||
for (int i = 1; i < len; ++i) {
|
||||
//我们此时知道了 [0,i-1]的最长前后缀，但是k+1的指向的值和i不相同时，我们则需要回溯
|
||||
//因为 next[k]就时用来记录子串的最长公共前后缀的尾坐标（即长度）
|
||||
//就要找 k+1前一个元素在next数组里的值,即next[k+1]
|
||||
while (k != -1 && needle[k + 1] != needle[i]) {
|
||||
k = next[k];
|
||||
}
|
||||
// 相同情况，就是 k的下一位，和 i 相同时，此时我们已经知道 [0,i-1]的最长前后缀
|
||||
//然后 k - 1 又和 i 相同，最长前后缀加1，即可
|
||||
if (needle[k+1] == needle[i]) {
|
||||
++k;
|
||||
}
|
||||
next[i] = k;
|
||||
|
||||
}
|
||||
return next;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
486
gif-algorithm/数据结构和算法/字符串匹配算法.md
Normal file
486
gif-algorithm/数据结构和算法/字符串匹配算法.md
Normal file
@@ -0,0 +1,486 @@
|
||||
|
||||
|
||||
> 为保证代码严谨性，文中所有代码均在 leetcode 刷题网站 AC ，大家可以放心食用。
|
||||
|
||||
皇上生辰之际，举国同庆，袁记菜馆作为天下第一饭店，所以被选为这次庆典的菜品供应方，这次庆典对于袁记菜馆是一项前所未有的挑战，毕竟是第一次给皇上庆祝生辰，稍有不慎就是掉脑袋的大罪，整个袁记菜馆内都在紧张的布置着。此时突然有一个店小二慌慌张张跑到袁厨面前汇报，到底发生了什么事，让店小二如此慌张呢？
|
||||
|
||||
袁记菜馆内
|
||||
|
||||
店小二：不好了不好了，掌柜的，出大事了。
|
||||
|
||||
袁厨：发生什么事了，慢慢说，如此慌张，成何体统。（开店开久了，架子出来了哈）
|
||||
|
||||
店小二：皇上按照咱们菜单点了 666 道菜，但是咱们做西湖醋鱼的师傅请假回家结婚了，不知道皇上有没有点这道菜，如果点了这道菜，咱们做不出来，那咱们店可就完了啊。
|
||||
|
||||
（袁厨听了之后，吓得一屁股坐地上了，缓了半天说道）
|
||||
|
||||
袁厨：别说那么多了，快给我找找皇上点的菜里面，有没有这道菜！
|
||||
|
||||
找了很久，并且核对了很多遍，最后确认皇上没有点这道菜。菜馆内的人都松了一口气
|
||||
|
||||
通过上面的一个例子，让我们简单了解了字符串匹配。
|
||||
|
||||
字符串匹配：设 S 和 T 是给定的两个串，在主串 S 中找到模式串 T 的过程称为字符串匹配，如果在主串 S 中找到 模式串 T ，则称匹配成功，函数返回 T 在 S 中首次出现的位置，否则匹配不成功，返回 -1。
|
||||
|
||||
例：
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
在上图中，我们试图找到模式 T = baab,在主串 S = abcabaabcabac 中第一次出现的位置，即为红色阴影部分， T 第一次在 S 中出现的位置下标为 4 （ 字符串的首位下标是 0 ），所以返回 4。如果模式串 T 没有在主串 S 中出现，则返回 -1。
|
||||
|
||||
解决上面问题的算法我们称之为字符串匹配算法，今天我们来介绍三种字符串匹配算法，大家记得打卡呀，说不准面试的时候就问到啦。
|
||||
|
||||
## BF算法（Brute Force）
|
||||
|
||||
这个算法很容易理解，就是我们将模式串和主串进行比较，一致时则继续比较下一字符，直到比较完整个模式串。不一致时则将模式串后移一位，重新从模式串的首位开始对比，重复刚才的步骤下面我们看下这个方法的动图解析，看完肯定一下就能搞懂啦。
|
||||
|
||||
视频详解
|
||||
|
||||
**因为不可以放置视频，所以想看视频的同学，可以去看公众号原文，那里有视频**
|
||||
|
||||
通过上面的代码是不是一下就将这个算法搞懂啦，下面我们用这个算法来解决下面这个经典题目吧。
|
||||
|
||||
### leetcdoe 28. 实现 strStr()
|
||||
|
||||
#### 题目描述
|
||||
|
||||
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
|
||||
|
||||
示例 1:
|
||||
|
||||
> 输入: haystack = "hello", needle = "ll"
|
||||
> 输出: 2
|
||||
|
||||
示例 2:
|
||||
|
||||
> 输入: haystack = "aaaaa", needle = "bba"
|
||||
> 输出: -1
|
||||
|
||||
#### 题目解析
|
||||
|
||||
其实这个题目很容易理解，但是我们需要注意的是一下几点，比如我们的模式串为 0 时，应该返回什么，我们的模式串长度大于主串长度时，应该返回什么，也是我们需要注意的地方。下面我们来看一下题目代码吧。
|
||||
|
||||
#### 题目代码
|
||||
|
||||
```java
|
||||
class Solution {
|
||||
public int strStr(String haystack, String needle) {
|
||||
int haylen = haystack.length();
|
||||
int needlen = needle.length();
|
||||
//特殊情况
|
||||
if (haylen < needlen) {
|
||||
return -1;
|
||||
}
|
||||
if (needlen == 0) {
|
||||
return 0;
|
||||
}
|
||||
//主串
|
||||
for (int i = 0; i < haylen - needlen + 1; ++i) {
|
||||
int j;
|
||||
//模式串
|
||||
for (j = 0; j < needlen; j++) {
|
||||
//不符合的情况，直接跳出，主串指针后移一位
|
||||
if (haystack.charAt(i+j) != needle.charAt(j)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
//匹配成功
|
||||
if (j == needlen) {
|
||||
return i;
|
||||
}
|
||||
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
我们看一下BF算法的另一种算法（显示回退），其实原理一样，就是对代码进行了一下修改，只要是看完咱们的动图，这个也能够一下就能看懂，大家可以结合下面代码中的注释和动图进行理解。
|
||||
|
||||
```java
|
||||
class Solution {
|
||||
public int strStr(String haystack, String needle) {
|
||||
//i代表主串指针，j模式串
|
||||
int i,j;
|
||||
//主串长度和模式串长度
|
||||
int halen = haystack.length();
|
||||
int nelen = needle.length();
|
||||
//循环条件，这里只有 i 增长
|
||||
for (i = 0 , j = 0; i < halen && j < nelen; ++i) {
|
||||
//相同时，则移动 j 指针
|
||||
if (haystack.charAt(i) == needle.charAt(j)) {
|
||||
++j;
|
||||
} else {
|
||||
//不匹配时，将 j 重新指向模式串的头部，将 i 本次匹配的开始位置的下一字符
|
||||
i -= j;
|
||||
j = 0;
|
||||
}
|
||||
}
|
||||
//查询成功时返回索引，查询失败时返回 -1；
|
||||
int renum = j == nelen ? i - nelen : -1;
|
||||
return renum;
|
||||
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
## BM算法(Boyer-Moore)
|
||||
|
||||
我们刚才说过了 BF 算法，但是 BF 算法是有缺陷的，比如我们下面这种情况
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
如上图所示，如果我们利用 BF 算法，遇到不匹配字符时，每次右移一位模式串，再重新从头进行匹配，我们观察一下，我们的模式串 abcdex 中每个字符都不一样，但是我们第一次进行字符串匹配时，abcde 都匹配成功，到 x 时失败，又因为模式串每位都不相同，所以我们不需要再每次右移一位，再重新比较，我们可以直接跳过某些步骤。如下图
|
||||
|
||||
|
||||
|
||||
我们可以跳过其中某些步骤，直接到下面这个步骤。那我们是依据什么原则呢？
|
||||
|
||||
|
||||
|
||||
### 坏字符规则
|
||||
|
||||
我们之前的 BF 算法是从前往后进行比较 ，BM 算法是从后往前进行比较，我们来看一下具体过程，我们还是利用上面的例子。
|
||||
|
||||
|
||||
|
||||
BM 算法是从后往前进行比较，此时我们发现比较的第一个字符就不匹配，我们将**主串**这个字符称之为**坏字符**，也就是 f ,我们发现坏字符之后，模式串 T 中查找是否含有该字符（f），我们发现并不存在 f，此时我们只需将模式串右移到坏字符的后面一位即可。如下图
|
||||
|
||||
|
||||
|
||||
那我们在模式串中找到坏字符该怎么办呢？
|
||||
|
||||
|
||||
|
||||
此时我们的坏字符为 f ,我们在模式串中，查找发现含有坏字符 f,我们则需要移动模式串 T ,将模式串中的 f 和坏字符对齐。见下图。
|
||||
|
||||
|
||||
|
||||
然后我们继续从右往左进行比较，发现 d 为坏字符，则需要将模式串中的 d 和坏字符对齐。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
那么我们在来思考一下这种情况，那就是模式串中含有多个坏字符怎么办呢？
|
||||
|
||||
|
||||
|
||||
那么我们为什么要让**最靠右的对应元素与坏字符匹配**呢？如果上面的例子我们没有按照这条规则看下会产生什么问题。
|
||||
|
||||
|
||||
|
||||
如果没有按照我们上述规则，则会**漏掉我们的真正匹配**。我们的主串中是**含有 babac** 的，但是却**没有匹配成功**，所以应该遵守**最靠右的对应字符与坏字符相对**的规则。
|
||||
|
||||
我们上面一共介绍了三种移动情况，分别是下方的模式串中没有发现与坏字符对应的字符，发现一个对应字符，发现两个。这三种情况我们分别移动不同的位数，那我们是根据依据什么来决定移动位数的呢？下面我们给图中的字符加上下标。见下图
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
下面我们来考虑一下这种情况。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
此时这种情况肯定是不行的，不往右移动，甚至还有可能左移，那么我们有没有什么办法解决这个问题呢？继续往下看吧。
|
||||
|
||||
### 好后缀规则
|
||||
|
||||
好后缀其实也很容易理解，我们之前说过 BM 算法是从右往左进行比较，下面我们来看下面这个例子。
|
||||
|
||||
|
||||
|
||||
这里如果我们按照坏字符进行移动是不合理的，这时我们可以使用好后缀规则，那么什么是好后缀呢？
|
||||
|
||||
BM 算法是从右往左进行比较，发现坏字符的时候此时 cac 已经匹配成功，在红色阴影处发现坏字符。此时已经匹配成功的 cac 则为我们的好后缀，此时我们拿它在模式串中查找，如果找到了另一个和好后缀相匹配的串，那我们就将另一个和**好后缀相匹配**的串 ，滑到和好后缀对齐的位置。
|
||||
|
||||
是不是感觉有点拗口，没关系，我们看下图，红色代表坏字符，绿色代表好后缀
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
上面那种情况搞懂了，但是我们思考一下下面这种情况
|
||||
|
||||
|
||||
|
||||
上面我们说到了，如果在模式串的**头部**没有发现好后缀，发现好后缀的子串也可以。但是为什么要强调这个头部呢？
|
||||
|
||||
我们下面来看一下这种情况
|
||||
|
||||
|
||||
|
||||
但是当我们在头部发现好后缀的子串时，是什么情况呢？
|
||||
|
||||
|
||||
|
||||
下面我们通过动图来看一下某一例子的具体的执行过程
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
视频
|
||||
|
||||
|
||||
|
||||
说到这里，坏字符和好后缀规则就算说完了，坏字符很容易理解，我们对好后缀总结一下
|
||||
|
||||
1.如果模式串**含有好后缀**，无论是中间还是头部可以按照规则进行移动。如果好后缀在模式串中出现多次，则以**最右侧的好后缀**为基准。
|
||||
|
||||
2.如果模式串**头部含有**好后缀子串则可以按照规则进行移动，中间部分含有好后缀子串则不可以。
|
||||
|
||||
3.如果在模式串尾部就出现不匹配的情况，即不存在好后缀时，则根据坏字符进行移动，这里有的文章没有提到，是个需要特别注意的地方，我是在这个论文里找到答案的，感兴趣的同学可以看下。
|
||||
|
||||
> Boyer R S，Moore J S. A fast string searching algorithm［J］. Communications of the ACM，1977，10： 762-772.
|
||||
|
||||
|
||||
|
||||
之前我们刚开始说坏字符的时候，是不是有可能会出现负值的情况，即往左移动的情况，所以我们为了解决这个问题，我们可以分别计算好后缀和坏字符往后滑动的位数**（好后缀不为 0 的情况）**，然后取两个数中最大的，作为模式串往后滑动的位数。
|
||||
|
||||
|
||||
|
||||
这破图画起来是真费劲啊。下面我们来看一下算法代码，代码有点长，我都标上了注释也在网站上 AC 了，如果各位感兴趣可以看一下，不感兴趣理解坏字符和好后缀规则即可。可以直接跳到 KMP 部分
|
||||
|
||||
```java
|
||||
class Solution {
|
||||
public int strStr(String haystack, String needle) {
|
||||
char[] hay = haystack.toCharArray();
|
||||
char[] need = needle.toCharArray();
|
||||
int haylen = haystack.length();
|
||||
int needlen = need.length;
|
||||
return bm(hay,haylen,need,needlen);
|
||||
}
|
||||
//用来求坏字符情况下移动位数
|
||||
private static void badChar(char[] b, int m, int[] bc) {
|
||||
//初始化
|
||||
for (int i = 0; i < 256; ++i) {
|
||||
bc[i] = -1;
|
||||
}
|
||||
//m 代表模式串的长度，如果有两个 a,则后面那个会覆盖前面那个
|
||||
for (int i = 0; i < m; ++i) {
|
||||
int ascii = (int)b[i];
|
||||
bc[ascii] = i;//下标
|
||||
}
|
||||
}
|
||||
//用来求好后缀条件下的移动位数
|
||||
private static void goodSuffix (char[] b, int m, int[] suffix,boolean[] prefix) {
|
||||
//初始化
|
||||
for (int i = 0; i < m; ++i) {
|
||||
suffix[i] = -1;
|
||||
prefix[i] = false;
|
||||
}
|
||||
for (int i = 0; i < m - 1; ++i) {
|
||||
int j = i;
|
||||
int k = 0;
|
||||
while (j >= 0 && b[j] == b[m-1-k]) {
|
||||
--j;
|
||||
++k;
|
||||
suffix[k] = j + 1;
|
||||
}
|
||||
if (j == -1) prefix[k] = true;
|
||||
}
|
||||
}
|
||||
public static int bm (char[] a, int n, char[] b, int m) {
|
||||
|
||||
int[] bc = new int[256];//创建一个数组用来保存最右边字符的下标
|
||||
badChar(b,m,bc);
|
||||
//用来保存各种长度好后缀的最右位置的数组
|
||||
int[] suffix_index = new int[m];
|
||||
//判断是否是头部，如果是头部则true
|
||||
boolean[] ispre = new boolean[m];
|
||||
goodSuffix(b,m,suffix_index,ispre);
|
||||
int i = 0;//第一个匹配字符
|
||||
//注意结束条件
|
||||
while (i <= n-m) {
|
||||
int j;
|
||||
//从后往前匹配，匹配失败，找到坏字符
|
||||
for (j = m - 1; j >= 0; --j) {
|
||||
if (a[i+j] != b[j]) break;
|
||||
}
|
||||
//模式串遍历完毕，匹配成功
|
||||
if (j < 0) {
|
||||
return i;
|
||||
}
|
||||
//下面为匹配失败时，如何处理
|
||||
//求出坏字符规则下移动的位数，就是我们坏字符下标减最右边的下标
|
||||
int x = j - bc[(int)a[i+j]];
|
||||
int y = 0;
|
||||
//好后缀情况，求出好后缀情况下的移动位数,如果不含有好后缀的话，则按照坏字符来
|
||||
if (y < m-1 && m - 1 - j > 0) {
|
||||
y = move(j, m, suffix_index,ispre);
|
||||
}
|
||||
//移动
|
||||
i = i + Math.max(x,y);
|
||||
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
// j代表坏字符的下标
|
||||
private static int move (int j, int m, int[] suffix_index, boolean[] ispre) {
|
||||
//好后缀长度
|
||||
int k = m - 1 - j;
|
||||
//如果含有长度为 k 的好后缀，返回移动位数，
|
||||
if (suffix_index[k] != -1) return j - suffix_index[k] + 1;
|
||||
//找头部为好后缀子串的最大长度，从长度最大的子串开始
|
||||
for (int r = j + 2; r <= m-1; ++r) {
|
||||
//如果是头部
|
||||
if (ispre[m-r] == true) {
|
||||
return r;
|
||||
}
|
||||
}
|
||||
//如果没有发现好后缀匹配的串，或者头部为好后缀子串，则移动到 m 位，也就是匹配串的长度
|
||||
return m;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
我们来理解一下我们代码中用到的两个数组，因为两个规则的移动位数，只与模式串有关，与主串无关，所以我们可以提前求出每种情况的移动情况，保存到数组中。
|
||||
|
||||
|
||||
|
||||
## KMP算法（Knuth-Morris-Pratt）
|
||||
|
||||
我们刚才讲了 BM 算法，虽然不是特别容易理解，但是如果你用心看的话肯定可以看懂的，我们再来看一个新的算法，这个算法是考研时必考的算法。实际上 BM 和 KMP 算法的本质是一样的，你理解了 BM 再来理解 KMP 那就是分分钟的事啦。
|
||||
|
||||
我们先来看一个实例
|
||||
|
||||
视频
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
为了让读者更容易理解，我们将指针移动改成了模式串移动，两者相对与主串的移动是一致的，重新比较时都是从指针位置继续比较。
|
||||
|
||||
通过上面的实例是不是很快就能理解 KMP 算法的思想了，但是 KMP 的难点不是在这里，不过多思考，认真看理解起来也是很轻松的。
|
||||
|
||||
在上面的例子中我们提到了一个名词，**最长公共前后缀**，这个是什么意思呢？下面我们通过一个较简单的例子进行描述。
|
||||
|
||||
|
||||
|
||||
此时我们在红色阴影处匹配失败，绿色为匹配成功部分，则我们观察匹配成功的部分。
|
||||
|
||||
我们来看一下匹配成功部分的所有前缀
|
||||
|
||||
|
||||
|
||||
我们的最长公共前后缀如下图，则我们需要这样移动
|
||||
|
||||
|
||||
|
||||
好啦，看完上面的图，KMP的核心原理已经基本搞定了，但是我们现在的问题是，我们应该怎么才能知道他的最长公共前后缀的长度是多少呢？怎么知道移动多少位呢？
|
||||
|
||||
刚才我们在 BM 中说到，我们移动位数跟主串无关，只跟模式串有关，跟我们的 bc,suffix,prefix 数组的值有关，我们通过这些数组就可以知道我们每次移动多少位啦，其实 KMP 也有一个数组，这个数组叫做 next 数组，那么这个 next 数组存的是什么呢？
|
||||
|
||||
next 数组存的咱们最长公共前后缀中，前缀的结尾字符下标。是不是感觉有点别扭，我们通过一个例子进行说明。
|
||||
|
||||
|
||||
|
||||
我们知道 next 数组之后，我们的 KMP 算法实现起来就很容易啦，另外我们看一下 next 数组到底是干什么用的。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
剩下的就不用说啦，完全一致啦，咱们将上面这个例子，翻译成和咱们开头对应的动画大家看一下。
|
||||
|
||||
**因为不可以放置视频，所以想看视频的同学，可以去看公众号原文，那里有视频**
|
||||
|
||||
下面我们看一下代码，标有详细注释，大家认真看呀。
|
||||
|
||||
**注：很多教科书的 next 数组表示方式不一致，理解即可**
|
||||
|
||||
```java
|
||||
class Solution {
|
||||
public int strStr(String haystack, String needle) {
|
||||
//两种特殊情况
|
||||
if (needle.length() == 0) {
|
||||
return 0;
|
||||
}
|
||||
if (haystack.length() == 0) {
|
||||
return -1;
|
||||
}
|
||||
// char 数组
|
||||
char[] hasyarr = haystack.toCharArray();
|
||||
char[] nearr = needle.toCharArray();
|
||||
//长度
|
||||
int halen = hasyarr.length;
|
||||
int nelen = nearr.length;
|
||||
//返回下标
|
||||
return kmp(hasyarr,halen,nearr,nelen);
|
||||
|
||||
}
|
||||
public int kmp (char[] hasyarr, int halen, char[] nearr, int nelen) {
|
||||
//获取next 数组
|
||||
int[] next = next(nearr,nelen);
|
||||
int j = 0;
|
||||
for (int i = 0; i < halen; ++i) {
|
||||
//发现不匹配的字符，然后根据 next 数组移动指针，移动到最大公共前后缀的，
|
||||
//前缀的后一位,和咱们移动模式串的含义相同
|
||||
while (j > 0 && hasyarr[i] != nearr[j]) {
|
||||
j = next[j - 1] + 1;
|
||||
//超出长度时，可以直接返回不存在
|
||||
if (nelen - j + i > halen) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
//如果相同就将指针同时后移一下，比较下个字符
|
||||
if (hasyarr[i] == nearr[j]) {
|
||||
++j;
|
||||
}
|
||||
//遍历完整个模式串，返回模式串的起点下标
|
||||
if (j == nelen) {
|
||||
return i - nelen + 1;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
//这一块比较难懂，不想看的同学可以忽略，了解大致含义即可，或者自己调试一下，看看运行情况
|
||||
//我会每一步都写上注释
|
||||
public int[] next (char[] needle,int len) {
|
||||
//定义 next 数组
|
||||
int[] next = new int[len];
|
||||
// 初始化
|
||||
next[0] = -1;
|
||||
int k = -1;
|
||||
for (int i = 1; i < len; ++i) {
|
||||
//我们此时知道了 [0,i-1]的最长前后缀，但是k+1的指向的值和i不相同时，我们则需要回溯
|
||||
//因为 next[k]就时用来记录子串的最长公共前后缀的尾坐标（即长度）
|
||||
//就要找 k+1前一个元素在next数组里的值,即next[k+1]
|
||||
while (k != -1 && needle[k + 1] != needle[i]) {
|
||||
k = next[k];
|
||||
}
|
||||
// 相同情况，就是 k的下一位，和 i 相同时，此时我们已经知道 [0,i-1]的最长前后缀
|
||||
//然后 k - 1 又和 i 相同，最长前后缀加1，即可
|
||||
if (needle[k+1] == needle[i]) {
|
||||
++k;
|
||||
}
|
||||
next[i] = k;
|
||||
|
||||
}
|
||||
return next;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
这篇文章真的写了很久很久，觉得还不错的话，就麻烦您点个赞吧，大家也可以去我的公众号看我的所有文章，每个都有动图解析，公众号：[袁厨的算法小屋](https://cdn.jsdelivr.net/gh/tan45du/tan45du.github.io.photo@master/photo/qrcode_for_gh_1f36d2ef6df9_258.5lojyphpkso0.jpg)
|
||||
|
||||
Reference in New Issue
Block a user