算法图解的代码

1. 两道编程算法题（两图一道），题目如下，可以给出算法思路或者源代码，源代码最好是C语言的

就会个第一题(因为第一题上已经给出了大致思路)

思路:用map容器(它的内部数据结构是一颗红黑树，查找和插入数据速度非常快)
map<int,st>a;//key(int)：设置为1~n的数;value(st):设置为key的前驱和后继；

这样一来就可以像链表快速插入数据，又可以像数组随机访问元素(key,就相当于数组的下标)

下面是代码和运行截图；

看代码前建议先了解一下map容器的具体用法;

#include<iostream>

#include<map>

#include<vector>

using namespace std;

struct st{//两个成员变量用来储存前驱和后继

int left;//0

int right;//1

st()

{

left=0;

right=0;

}

};

void input(map<int,st> &a)//输出

{

st t;

int s=0;

map<int,st>::iterator it;//迭代器(指针)

for(it=a.begin();it!=a.end();it++)//循环迭代

{

t=it->second;

if(t.left==0)//左边等于0,说明该数是第一个数

{

s=it->first;//记录key

break;

}

}

t=a[s];

cout<<s<<" ";

while(t.right!=0)//循环找当前数的右边的数(右边的为0，就说明该数是最后一个数)

{

cout<<t.right<<" ";

t=a[t.right];

}

}

int main()

{

st t,t_i,t_x,t_k,s;

map<int,st>a;

map<int,st>::iterator it;

int n,x,p,x_l,x_r;

cin>>n;

for(int i=1;i<=n;i++)//map容器赋初值(i,t)

//i:(key)下标;t:(value)结构体变量

{

a.insert(make_pair(i,t));

}

for(int i=2;i<=n;i++)

{

cin>>x>>p;

if(p==0)//x的左边插入i

{

t=a[x];

if(t.left==0)//x的左边没有数

{

t_x.left=i;

t_i.right=x;

a[x]=t_x;

a[i]=t_i;

}

else//x的左边有数

{

int x_left;

t_x=a[x];

x_left=t_x.left;

t_k=a[x_left];

t_i.right=x;

t_i.left=t_x.left;

t_k.right=i;

t_x.left=i;

a[x]=t_x;

a[i]=t_i;

a[x_left]=t_k;

}

}

else//x的右边插入i

{

t=a[x];

if(t.right==0)//x的右边没有数

{

t_x.right=i;

t_i.left=x;

a[x]=t_x;

a[i]=t_i;

}

else//x的左边有数

{

int x_right;

t_x=a[x];

x_right=t_x.right;

t_k=a[x_right];

t_i.left=x;

t_i.right=t_x.right;

t_k.left=i;

t_x.right=i;

a[x]=t_x;

a[i]=t_i;

a[x_right]=t_k;

}

}

}

for(it=a.begin();it!=a.end();it++)//循环迭代打印各个数之间的关系

{

cout<<it->first<<" ";

cout<<"左边:";

cout<<it->second.left<<" ";

cout<<"右边:";

cout<<it->second.right<<endl;

}

input(a);//打印序列

return 0;

}

/*

4

1 0

2 1

1 0

2 3 4 1

*/

2. 算法图解 pdf 高清版

像小说集一样趣味的算法新手入门书。
算法是解决困难的一步步步骤，都是电子信息科学行业的关键主题。现如今程序员*常见的算法早已历经了古人的探索、检测及证实。假如你要搞明白这种算法，又不愿困在在繁杂的证实中，这书更是你的不二选择。这部图例丰富多彩、扣人心弦的好用手册将给你轻轻松松懂得怎样在自身的程序流程中高效率应用关键的算法。
这书范例丰富多彩，图片配文字，以令人非常容易了解的方法诠释了算法，致力于协助程序员在平时新项目中充分发挥算法的动能。书中的前三章将协助你奠定基础，陪你学习培训二分查找、大O表示法、二种基础的数据结构及其递归等。剩下的篇数将关键详细介绍运用普遍的算法，主要内容包含：应对实际难题时的处理方法，例如，什么时候选用贪欲算法或动态规划；散列表的运用；图算法；Kzui近邻算法。

目录
前言
致谢
关于本书
第1章 算法简介1
1.1引言1
1.1.1性能方面1
1.1.2问题解决技巧2
1.2二分查找2
1.2.1更佳的查找方式4
1.2.2运行时间8
1.3大O 表示法8
1.3.1算法的运行时间以不同的速度增加9
1.3.2理解不同的大O运行时间10
1.3.3大O 表示法指出了最糟情况下的运行时间12
1.3.4一些常见的大O运行时间12
1.3.5旅行商13
1.4小结15
第2章 选择排序16
2.1内存的工作原理16
2.2数组和链表18
2.2.1链表19
2.2.2数组20
2.2.3术语21
2.2.4在中间插入22
2.2.5删除23
2.3选择排序25
2.4小结28
第3章 递归29
3.1递归29
3.2基线条件和递归条件32
3.3栈33
3.3.1调用栈34
3.3.2递归调用栈36
3.4小结40
第4章 快速排序41
4.1分而治之41
4.2快速排序47
4.3再谈大O表示法52
4.3.1比较合并排序和快速排序53
4.3.2平均情况和最糟情况54
4.4小结57
第5章 散列表58
5.1散列函数60
5.2应用案例63
5.2.1将散列表用于查找63
5.2.2防止重复64
5.2.3将散列表用作缓存66
5.2.4小结68
5.3冲突69
5.4性能71
5.4.1填装因子72
5.4.2良好的散列函数74
5.5小结75
第6章 广度优先搜索76
6.1图简介77
6.2图是什么79
6.3广度优先搜索79
6.3.1查找最短路径82
6.3.2队列83
6.4实现图84
6.5实现算法86
6.6小结93
第7章 狄克斯特拉算法94
7.1使用狄克斯特拉算法95
7.2术语98
7.3换钢琴100
7.4负权边105
7.5实现108
7.6小结116
第8章 贪婪算法117
8.1教室调度问题117
8.2背包问题119
8.3集合覆盖问题121
8.4NP 完全问题127
8.4.1旅行商问题详解127
8.4.2如何识别NP 完全问题131
8.5小结133
第9章 动态规划134
9.1背包问题134
9.1.1简单算法135
9.1.2动态规划136
9.2背包问题FAQ143
9.2.1再增加一件商品将如何呢143
9.2.2行的排列顺序发生变化时结果将如何145
9.2.3可以逐列而不是逐行填充网格吗146
9.2.4增加一件更小的商品将如何呢146
9.2.5可以偷商品的一部分吗146
9.2.6旅游行程最优化147
9.2.7处理相互依赖的情况148
9.2.8计算最终的解时会涉及两个以上的子背包吗148
9.2.9最优解可能导致背包没装满吗149
9.3最长公共子串149
9.3.1绘制网格150
9.3.2填充网格151
9.3.3揭晓答案152
9.3.4最长公共子序列153
9.3.5最长公共子序列之解决方案154
9.4小结155
第10章 K 最近邻算法156
10.1橙子还是柚子156
10.2创建推荐系统158
10.2.1特征抽取159
10.2.2回归162
10.2.3挑选合适的特征164
10.3机器学习简介165
10.3.1OCR165
10.3.2创建垃圾邮件过滤器166
10.3.3预测股票市场167
10.4小结167
第11章 接下来如何做168
11.1树168
11.2反向索引171
11.3傅里叶变换171
11.4并行算法172
11.5MapRece173
11.5.1分布式算法为何很有用173
11.5.2映射函数173
11.5.3归并函数174
11.6布隆过滤器和HyperLogLog174
11.6.1布隆过滤器175
11.6.2HyperLogLog176
11.7SHA 算法176
11.7.1比较文件177
11.7.2检查密码178
11.8局部敏感的散列算法178
11.9Diffie-Hellman 密钥交换179
11.10线性规划180
11.11结语180
练习答案181

自取： https://url80.ctfile.com/f/32319880-518802548-9892a0
（访问密码：3284）

3. 如何理解《算法图解》中的快速排序算法

快速排序的基本思想就是从一个数组中任意挑选一个元素（通常来说会选择最左边的元素）作为中轴元素，将剩下的元素以中轴元素作为比较的标准，将小于等于中轴元素的放到中轴元素的左边，将大于中轴元素的放到中轴元素的右边。

然后以当前中轴元素的位置为界，将左半部分子数组和右半部分子数组看成两个新的数组，重复上述操作，直到子数组的元素个数小于等于1（因为一个元素的数组必定是有序的）。

以下的代码中会常常使用交换数组中两个元素值的Swap方法，其代码如下

publicstaticvoidSwap(int[] A, inti, intj){

inttmp;

tmp = A[i];

A[i] = A[j];

A[j] = tmp;

(3)算法图解的代码扩展阅读：

快速排序算法 的基本思想是：将所要进行排序的数分为左右两个部分，其中一部分的所有数据都比另外一 部分的数据小，然后将所分得的两部分数据进行同样的划分，重复执行以上的划分操作，直 到所有要进行排序的数据变为有序为止。

定义两个变量low和high，将low、high分别设置为要进行排序的序列的起始元素和最后一个元素的下标。第一次，low和high的取值分别为0和n-1，接下来的每次取值由划分得到的序列起始元素和最后一个元素的下标来决定。

定义一个变量key，接下来以key的取值为基准将数组A划分为左右两个部分，通 常，key值为要进行排序序列的第一个元素值。第一次的取值为A[0]，以后毎次取值由要划 分序列的起始元素决定。

从high所指向的数组元素开始向左扫描，扫描的同时将下标为high的数组元素依次与划分基准值key进行比较操作，直到high不大于low或找到第一个小于基准值key的数组元素，然后将该值赋值给low所指向的数组元素，同时将low右移一个位置。

如果low依然小于high，那么由low所指向的数组元素开始向右扫描，扫描的同时将下标为low的数组元素值依次与划分的基准值key进行比较操作，直到low不小于high或找到第一个大于基准值key的数组元素，然后将该值赋给high所指向的数组元素，同时将high左移一个位置。

重复步骤(3) (4)，直到low的植不小于high为止，这时成功划分后得到的左右两部分分别为A[low……pos-1]和A[pos+1……high]，其中，pos下标所对应的数组元素的值就是进行划分的基准值key，所以在划分结束时还要将下标为pos的数组元素赋值 为 key。

4. 求图割算法 graph cut 的matlab代码

解决方案1：
直接用缉鼎光刮叱钙癸水含惊ifft();例如信号x
y=fft(x);%对信号傅里叶变换到频域
z=ifft(y);%对信号y傅里叶反变换到时域，

解决方案2：
工具箱啊。IFFT()函数

5. 《算法图解》pdf

本书示例丰富，图文并茂，以让人容易理解的方式阐释了算法，旨在帮助程序员在日常项目中更好地发挥算法的能量。书中的前三章将帮助你打下基础，带你学习二分查找、大O表示法、两种基本的数据结构以及递归等。余下的篇幅将主要介绍应用广泛的算法，具体内容包括：面对具体问题时的解决技巧，比如，何时采用贪婪算法或动态规划；散列表的应用；图算法；Kzui近邻算法。

目录
前言
致谢
关于本书
第1章 算法简介1
1．1引言1
1．1．1性能方面1
1．1．2问题解决技巧2
1．2二分查找2
1．2．1更佳的查找方式4
1．2．2运行时间8
1．3大O 表示法8
1．3．1算法的运行时间以不同的速度增加9
1．3．2理解不同的大O运行时间10
1．3．3大O 表示法指出了最糟情况下的运行时间12
1．3．4一些常见的大O运行时间12
1．3．5旅行商13
1．4小结15
第2章 选择排序16
2．1内存的工作原理16
2．2数组和链表18
2．2．1链表19
2．2．2数组20
2．2．3术语21
2．2．4在中间插入22
2．2．5删除23
2．3选择排序25
2．4小结28
第3章 递归29
3．1递归29
3．2基线条件和递归条件32
3．3栈33
3．3．1调用栈34
3．3．2递归调用栈36
3．4小结40
第4章 快速排序41
4．1分而治之41
4．2快速排序47
4．3再谈大O表示法52
4．3．1比较合并排序和快速排序53
4．3．2平均情况和最糟情况54
4．4小结57
第5章 散列表58
5．1散列函数60
5．2应用案例63
5．2．1将散列表用于查找63
5．2．2防止重复64
5．2．3将散列表用作缓存66
5．2．4小结68
5．3冲突69
5．4性能71
5．4．1填装因子72
5．4．2良好的散列函数74
5．5小结75
第6章 广度优先搜索76
6．1图简介77
6．2图是什么79
6．3广度优先搜索79
6．3．1查找最短路径82
6．3．2队列83
6．4实现图84
6．5实现算法86
6．6小结93
第7章 狄克斯特拉算法94
7．1使用狄克斯特拉算法95
7．2术语98
7．3换钢琴100
7．4负权边105
7．5实现108
7．6小结116
第8章 贪婪算法117
8．1教室调度问题117
8．2背包问题119
8．3集合覆盖问题121
8．4NP 完全问题127
8．4．1旅行商问题详解127
8．4．2如何识别NP 完全问题131
8．5小结133
第9章 动态规划134
9．1背包问题134
9．1．1简单算法135
9．1．2动态规划136
9．2背包问题FAQ143
9．2．1再增加一件商品将如何呢143
9．2．2行的排列顺序发生变化时结果将如何145
9．2．3可以逐列而不是逐行填充网格吗146
9．2．4增加一件更小的商品将如何呢146
9．2．5可以偷商品的一部分吗146
9．2．6旅游行程最优化147
9．2．7处理相互依赖的情况148
9．2．8计算最终的解时会涉及两个以上的子背包吗148
9．2．9最优解可能导致背包没装满吗149
9．3最长公共子串149
9．3．1绘制网格150
9．3．2填充网格151
9．3．3揭晓答案152
9．3．4最长公共子序列153
9．3．5最长公共子序列之解决方案154
9．4小结155
第10章 K 最近邻算法156
10．1橙子还是柚子156
10．2创建推荐系统158
10．2．1特征抽取159
10．2．2回归162
10．2．3挑选合适的特征164
10．3机器学习简介165
10．3．1OCR165
10．3．2创建垃圾邮件过滤器166
10．3．3预测股票市场167
10．4小结167
第11章 接下来如何做168
11．1树168
11．2反向索引171
11．3傅里叶变换171
11．4并行算法172
11．5MapRece173
11．5．1分布式算法为何很有用173
11．5．2映射函数173
11．5．3归并函数174
11．6布隆过滤器和HyperLogLog174
11．6．1布隆过滤器175
11．6．2HyperLogLog176
11．7SHA 算法176
11．7．1比较文件177
11．7．2检查密码178
11．8局部敏感的散列算法178
11．9Diffie-Hellman 密钥交换179
11．10线性规划180
11．11结语180
练习答案181

最后，这里为大家准备了几百本的互联网电子书，有需要的过来取吧。 点击获取

6. KMP算法详细代码

KMP.java

源代码为：

package algorithm.kmp;

/**
* KMP算法的Java实现例子与测试、分析
* @author 崔卫兵
* @date 2009-3-25
*/
public class KMP {
/**
* 对子串加以预处理，从而找到匹配失败时子串回退的位置
* 找到匹配失败时的最合适的回退位置，而不是回退到子串的第一个字符，即可提高查找的效率
* 因此为了找到这个合适的位置，先对子串预处理，从而得到一个回退位置的数组
* @param B，待查找子串的char数组
* @return
*/
public static int[] preProcess(char [] B) {
int size = B.length;
int[] P = new int[size];
P[0]=0;
int j=0;
//每循环一次，就会找到一个回退位置
for(int i=1;i<size;i++){
//当找到第一个匹配的字符时，即j>0时才会执行这个循环
//或者说p2中的j++会在p1之前执行（限于第一次执行的条件下）
//p1
while(j>0 && B[j]!=B[i]){
j=P[j];
}
//p2，由此可以看出，只有当子串中含有重复字符时，回退的位置才会被优化
if(B[j]==B[i]){
j++;
}
//找到一个回退位置j，把其放入P[i]中
P[i]=j;
}
return P;
}

/**
* KMP实现
* @param parStr
* @param subStr
* @return
*/
public static void kmp(String parStr, String subStr) {
int subSize = subStr.length();
int parSize = parStr.length();
char[] B = subStr.toCharArray();
char[] A = parStr.toCharArray();
int[] P = preProcess(B);
int j=0;
int k =0;
for(int i=0;i<parSize;i++){
//当找到第一个匹配的字符时，即j>0时才会执行这个循环
//或者说p2中的j++会在p1之前执行（限于第一次执行的条件下）
//p1
while(j>0 && B[j]!=A[i]){
//找到合适的回退位置
j=P[j-1];
}
//p2 找到一个匹配的字符
if(B[j]==A[i]){
j++;
}
//输出匹配结果，并且让比较继续下去
if(j==subSize){
j=P[j-1];
k++;
System.out.printf("Find subString '%s' at %d\n",subStr,i-subSize+1);
}
}
System.out.printf("Totally found %d times for '%s'.\n\n",k,subStr);
}

public static void main(String[] args) {
//回退位置数组为P[0, 0, 0, 0, 0, 0]
kmp("abcdeg, abcdeh, abcdef!这个会匹配1次","abcdef");
//回退位置数组为P[0, 0, 1, 2, 3, 4]
kmp("Test ititi ititit! Test ititit!这个会匹配2次","ititit");
//回退位置数组为P[0, 0, 0]
kmp("测试汉字的匹配，崔卫兵。这个会匹配1次","崔卫兵");
//回退位置数组为P[0, 0, 0, 1, 2, 3, 4, 5, 6]
kmp("这个会匹配0次","it1it1it1");
}
}

7. 图解查找算法之插值查找（带源码）

在前面我们了解了二分查找，就是把一个集合的元素一分为二，用中间值和目标查找值相比较，直到要查找的值和中间值相等，则表示查找成功，反之表示不成功。为什么这里会再次提到二分查找呢？事实上，插值查找是二分查找的升级版。

用一个很简单的例子就可以把插值查找解释的很清楚。在字典里面找”boy”这个单词时，我们肯定不会从第一页开始找，而是从首字母为b的位置开始查找，然后再找到第二个字母在字母表中的位置，找到对应的位置后，重复这个过程，这样就可以快速的找到目标单词。

接下来就介绍一下插值查找吧。

我们知道的的二分查找有一个必要的前提，必须是有序的数组才可以进行二分查找，同样插值查找也只能用于一个呈线性增长的有序数组中。

首先我们在数组中找到左边索引low和右边的索引high，目标查找值key

在二分查找中mid表示数组的中间值，而插值查找中mid表示一个自适应处，插值查找每次是从自适应mid处开始查找，mid的计算方式为：low + (key – arr[low]) / (arr[high] – arr[low]) * (high - low)；在这里mid表示的就是目标值key在序列总的所占比。

源码：

int func(int arr[], int len, int key)

{

      int low,high,mid;

      low = 0;

      high = len-1;

  int h = (key-arr[low])/(arr[high]-arr[low]);

      while(low <= high)

      {

          mid = h * (high - low);

          if(key < arr[mid])

          {

              high = mid - 1;

          }

          else if(key > arr[mid])

          {

            low = mid + 1;

          }

          else

          {

              return mid;

          }

      }

    return -1;

  }

8. 数独 算法 C语言 代码

当年我们做大程的时候本来也想做数独来着,后来时间不够没做成.不知道专业人士怎么编的,只能提供一点当时的思路给你,
1.9*9个格子对应一个数组A,数组的第一个值从0到9表示其中填的数字,0就是不填,另一个值表示它在桌面上的位置就是坐标
2.需要10张图片,空白和9个数字
3.通过对鼠标点击的反应改变格子数组A的值,且将相应图片覆盖在相应坐标上
4.事先输入若干组数组A的值(每组81个数),作为题库
5.进行游戏时随机抽取题库中的一组,再随机抽取若干格子显示出来,其他留白.
6.填完后用三个循环判断下每行每列每块是否有相同的数字,没有则通过.
具体编按钮、放图、鼠标点击响应等各种问题查一下书，有很多书上有很多教的这种一小段一小段的程序源代码，直接抄下就行了。
加油^^

9. 二分查找算法实现（图解）与实例

当我们要从一个序列中查找一个元素的时候，二分查找是一种非常快速的查找算法，二分查找又叫折半查找。

它对要查找的序列有两个要求，一是该序列必须是有序的（即该序列中的所有元素都是按照大小关系排好序的，升序和降序都可以，本文假设是升序排列的），二是该序列必须是顺序存储的。

如果一个序列是无序的或者是链表，那么该序列就不能进行二分查找。之所以被查找的序列要满足这样的条件，是由二分查找算法的原理决定的。

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

二分查找能应用于任何类型的数据，只要能将这些数据按照某种规则进行排序。然而，正因为它依赖于一个有序的集合，这使得它在处理那些频繁插入和删除操作的数据集时不太高效。这是因为，对于插入和操作来说，为了保证查找过程正常进行，必须保证数据集始终有序。相对于查找来说，维护一个有序数据集的代价更高。此外，元素必须存储在连续的空间中。因此，当待搜索的集合是相对静态的数据集时，此时使用二分查找是最好的选择。

二分查找算法的原理如下：

二分查找之所以快速，是因为它在匹配不成功的时候，每次都能排除剩余元素中一半的元素。因此可能包含目标元素的有效范围就收缩得很快，而不像顺序查找那样，每次仅能排除一个元素。

二分查找法实质上是不断地将有序数据集进行对半分割，并检查每个分区的中间元素。

此实现过程的实施是通过变量left和right控制一个循环来查找元素（其中left和right是正在查找的数据集的两个边界值）。

二分查找的时间复杂度取决于查找过程中分区数可能的最大值。对于一个有n个元素的数据集来说，最多可以进行O(㏒₂n)次分区。对于二分查找，这表示最终可能在最坏的情况下执行的检查的次数：例如，在没有找到目标时。所以二分查找的时间复杂度为O(㏒₂n)。

参考：
https://www.html.cn/qa/other/23018.html

https://www.cnblogs.com/idreamo/p/9000762.html

10. 图解KMP字符串匹配算法

kmp算法跟之前讲的bm算法思想有一定的相似性。之前提到过，bm算法中有个好后缀的概念，而在kmp中有个好前缀的概念，什么是好前缀，我们先来看下面这个例子。

观察上面这个例子，已经匹配的abcde称为好前缀，a与之后的bcde都不匹配，所以没有必要再比一次，直接滑动到e之后即可。
  那如果前缀中有互相匹配的字符呢？

观察上面这个例子，这个时候如果我们直接滑到好前缀之后，则会过度滑动，错失匹配子串。那我们如何根据好前缀来进行合理滑动？

  其实就是看当前的好前缀的前缀和后缀是否有匹配的，找到最长匹配长度，直接滑动。鉴于不止一次找最长匹配长度，我们完全可以先初始化一个数组，保存在当前好前缀情况下，最长匹配长度是多少，这时候我们的next数组就出来了。

  我们定义一个next数组，表示在当前好前缀下，好前缀的前缀和后缀的最长匹配子串长度，这个最长匹配长度表示这个子串之前已经匹配过匹配了，不需要再次进行匹配，直接从子串的下一个字符开始匹配。

 我们是否每次算next[i]时都需要每一个字符进行匹配，是否可以根据next[i - 1]进行推导以便减少不必要的比较。
  带着这个思路我们来看看下面的步骤：
  假设next[i - 1] = k - 1;
  如果modelStr[k] = modelStr[i] 则next[i]=k

如果modelStr[k] != modelStr[i]，我们是否可以直接认定next[i] = next[i - 1]？

通过上面这个例子，我们可以很清晰地看到，next[i]!=next[i-1]，那当modelStr[k]!=modelStr[i]时候，我们已知next[0],next[1]…next[i-1]，如何推导出next[i]呢？
  假设modelStr[x…i]是前缀后缀能匹配的最长后缀子串，那么最长匹配前缀子串为modelStr[0…i-x]

我们在求这个最长匹配串的时候，他的前面的次长匹配串（不包含当前i的），也就是modelStr[x…i-1]在之前应该是已经求解出来了的，因此我们只需要找到这个某一个已经求解的匹配串，假设前缀子串为modelStr[0…i-x-1],后缀子串为modelStr[x…i-1],且modelStr[i-x] == modelStr[i],这个前缀后缀子串即为次前缀子串，加上当前字符即为最长匹配前缀后缀子串。
代码实现
  首先在kmp算法中最主要的next数组，这个数组标志着截止到当前下标的最长前缀后缀匹配子串字符个数，kmp算法里面，如果某个前缀是好前缀，即与模式串前缀匹配，我们就可以利用一定的技巧不止向前滑动一个字符，具体看前面的讲解。我们提前不知道哪些是好前缀，并且匹配过程不止一次，因此我们在最开始调用一个初始化方法，初始化next数组。
  1.如果上一个字符的最长前缀子串的下一个字符==当前字符，上一个字符的最长前缀子串直接加上当前字符即可
  2.如果不等于，需要找到之前存在的最长前缀子串的下一个字符等于当前子串的，然后设置当前字符子串的最长前缀后缀子串

然后开始利用next数组进行匹配，从第一个字符开始匹配进行匹配，找到第一个不匹配的字符，这时候之前的都是匹配的，接下来先判断是否已经是完全匹配，是直接返回，不是，判断是否第一个就不匹配，是直接往后面匹配。如果有好前缀，这时候就利用到了next数组，通过next数组知道当前可以从哪个开始匹配，之前的都不用进行匹配。