一、串的定义
字符串并不是基本类型中的一种，它需要我们通过数据结构来实现，用来存储一连串的字符的数据结构，并提供一系列的方法来对字符串进行操作。
串：串是由零个或多个字符组成的有限序列，又叫字符串。
二、串的比较
开始比较之前我们来了解一下编码，大家在学习任何编程语言的时候，都会接触到编码这个概念，以为计算机只能识别0和1，所以字符在电脑中的存储就必须使用01编码来存储，大家最熟悉的应该是ASCII码，一共存储了256个字符，但是后面发现这根本不足以存储所有字符，于是出现了Unicode和UTF-8等编码。而这个编码可以理解为一个数字对应一个字符。所以我们对比字符串大小的时候，实质上是对比编码的大小。
- 字符数相同：从第一个字符开始比较，比较字符的编码大小，哪个字符串的字符大那么这个字符串就大于另一个字符串，如果相同，则继续对比下一个字符。如果所有字符均相同，则这两个字符串相等。
- 字符数不同：首先也是与字符数相同的时候一样的对比方法，但是若对比到较少字符数的字符串的最后一个字符时，仍然相同，则字符数较多的那个字符串较大。
三、串的抽象数据类型
//容易
ADT 串（string)
Data
串中元素仅由一个字符组成，相邻元素具有前驱和后继关系
Operation
StrAssign(T,*chars):生成一个其值等于字符串常量chars的串T。
StrCopy(T,S):串S存在，由串S复制得串T。
ClearString(S):串S存在，将串清空。
StringEmpty(S)：若串为空，则返回true，否则返回false。
StrLength(S):返回S的元素个数，即串S的长度。
StrCompare(S,T):若S>T，返回>0,S=T,返回=0，S<T，返回<0.
Concat(T,S1,S2):用T返回由S1和S2联接而成的新串。
SubString(Sub,S,pos,len):串S存在，1<=pos<=Strlength(S),
且0<=len<=Strlength(S)-pos+1.
用Sub返回串S的第pos个字符起长
度为len的子串。
Index（S,T,pos):串S和T存在，T是非空串，1<=pos<=Strlength(S).
若主串S中存在和串T值相同的字串，则返回它在主
串S中第pos个字符之后第一次出现的位置，否则返回0
Replace(S,T,V):串S，T和V存在，T是非空串。用V替换主串S中出现
的所有与T相等的不重叠的子串。
StrInsert(S,pos,T):串S和T存在，1<=pos<=Strlength(S)+1.在串S的
第pos个字符之前插入串T。
SteDelete(S,pos,len):串S存在，1<=pos<=StrLength(s)-len+1.从串
S中删除第pos个字符起长度为len的子串。
四、串的顺序存储结构（Java、C语言）
串的顺序存储结构依然是使用数组来实现的，数组中每一个位置存放一个字符，结尾的时候可以加一个结尾标识符，例如“\0”。这样在遍历的时候就方便我们进行识别和结束。
而对于串的一些操作，例如增加字符，删除字符，字符的拼接等操作，通过数组来实现可以很好地进行操作。
当然，这里存在一个不足就是，我们无法确定我们要存放多少个字符，因此，串的存储空间可在程序执行过程中动态分配而得。比如在计算机中存在一个自由存储区，叫做“堆”，这个堆可由C语言的动态分配函数来实现。
C语言代码
#include "string.h"
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 40 /* 存储空间初始分配量 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType; /* ElemType类型根据实际情况而定，这里假设为int */
typedef char String[MAXSIZE+1]; /* 0号单元存放串的长度 */
/* 生成一个其值等于chars的串T */
Status StrAssign(String T,char *chars)
{
int i;
if(strlen(chars)>MAXSIZE)
return ERROR;
else
{
T[0]=strlen(chars);
for(i=1;i<=T[0];i++)
T[i]=*(chars+i-1);
return OK;
}
}
/* 由串S复制得串T */
Status StrCopy(String T,String S)
{
int i;
for(i=0;i<=S[0];i++)
T[i]=S[i];
return OK;
}
/* 若S为空串,则返回TRUE,否则返回FALSE */
Status StrEmpty(String S)
{
if(S[0]==0)
return TRUE;
else
return FALSE;
}
/* 初始条件: 串S和T存在 */
/* 操作结果: 若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值<0 */
int StrCompare(String S,String T)
{
int i;
for(i=1;i<=S[0]&&i<=T[0];++i)
if(S[i]!=T[i])
return S[i]-T[i];
return S[0]-T[0];
}
/* 返回串的元素个数 */
int StrLength(String S)
{
return S[0];
}
/* 初始条件:串S存在。操作结果:将S清为空串 */
Status ClearString(String S)
{
S[0]=0;/* 令串长为零 */
return OK;
}
/* 用T返回S1和S2联接而成的新串。若未截断，则返回TRUE，否则FALSE */
Status Concat(String T,String S1,String S2)
{
int i;
if(S1[0]+S2[0]<=MAXSIZE)
{ /* 未截断 */
for(i=1;i<=S1[0];i++)
T[i]=S1[i];
for(i=1;i<=S2[0];i++)
T[S1[0]+i]=S2[i];
T[0]=S1[0]+S2[0];
return TRUE;
}
else
{ /* 截断S2 */
for(i=1;i<=S1[0];i++)
T[i]=S1[i];
for(i=1;i<=MAXSIZE-S1[0];i++)
T[S1[0]+i]=S2[i];
T[0]=MAXSIZE;
return FALSE;
}
}
/* 用Sub返回串S的第pos个字符起长度为len的子串。 */
Status SubString(String Sub,String S,int pos,int len)
{
int i;
if(pos<1||pos>S[0]||len<0||len>S[0]-pos+1)
return ERROR;
for(i=1;i<=len;i++)
Sub[i]=S[pos+i-1];
Sub[0]=len;
return OK;
}
/* 返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数返回值为0。 */
/* 其中,T非空,1≤pos≤StrLength(S)。 */
int Index(String S, String T, int pos)
{
int i = pos; /* i用于主串S中当前位置下标值，若pos不为1，则从pos位置开始匹配 */
int j = 1; /* j用于子串T中当前位置下标值 */
while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时，循环继续 */
{
if (S[i] == T[j]) /* 两字母相等则继续 */
{
++i;
++j;
}
else /* 指针后退重新开始匹配 */
{
i = i-j+2; /* i退回到上次匹配首位的下一位 */
j = 1; /* j退回到子串T的首位 */
}
}
if (j > T[0])
return i-T[0];
else
return 0;
}
/* T为非空串。若主串S中第pos个字符之后存在与T相等的子串， */
/* 则返回第一个这样的子串在S中的位置，否则返回0 */
int Index2(String S, String T, int pos)
{
int n,m,i;
String sub;
if (pos > 0)
{
n = StrLength(S); /* 得到主串S的长度 */
m = StrLength(T); /* 得到子串T的长度 */
i = pos;
while (i <= n-m+1)
{
SubString (sub, S, i, m); /* 取主串中第i个位置长度与T相等的子串给sub */
if (StrCompare(sub,T) != 0) /* 如果两串不相等 */
++i;
else /* 如果两串相等 */
return i; /* 则返回i值 */
}
}
return 0; /* 若无子串与T相等，返回0 */
}
/* 初始条件: 串S和T存在,1≤pos≤StrLength(S)+1 */
/* 操作结果: 在串S的第pos个字符之前插入串T。完全插入返回TRUE,部分插入返回FALSE */
Status StrInsert(String S,int pos,String T)
{
int i;
if(pos<1||pos>S[0]+1)
return ERROR;
if(S[0]+T[0]<=MAXSIZE)
{ /* 完全插入 */
for(i=S[0];i>=pos;i--)
S[i+T[0]]=S[i];
for(i=pos;i<pos+T[0];i++)
S[i]=T[i-pos+1];
S[0]=S[0]+T[0];
return TRUE;
}
else
{ /* 部分插入 */
for(i=MAXSIZE;i<=pos;i--)
S[i]=S[i-T[0]];
for(i=pos;i<pos+T[0];i++)
S[i]=T[i-pos+1];
S[0]=MAXSIZE;
return FALSE;
}
}
/* 初始条件: 串S存在,1≤pos≤StrLength(S)-len+1 */
/* 操作结果: 从串S中删除第pos个字符起长度为len的子串 */
Status StrDelete(String S,int pos,int len)
{
int i;
if(pos<1||pos>S[0]-len+1||len<0)
return ERROR;
for(i=pos+len;i<=S[0];i++)
S[i-len]=S[i];
S[0]-=len;
return OK;
}
/* 初始条件: 串S,T和V存在,T是非空串（此函数与串的存储结构无关） */
/* 操作结果: 用V替换主串S中出现的所有与T相等的不重叠的子串 */
Status Replace(String S,String T,String V)
{
int i=1; /* 从串S的第一个字符起查找串T */
if(StrEmpty(T)) /* T是空串 */
return ERROR;
do
{
i=Index(S,T,i); /* 结果i为从上一个i之后找到的子串T的位置 */
if(i) /* 串S中存在串T */
{
StrDelete(S,i,StrLength(T)); /* 删除该串T */
StrInsert(S,i,V); /* 在原串T的位置插入串V */
i+=StrLength(V); /* 在插入的串V后面继续查找串T */
}
}while(i);
return OK;
}
/* 输出字符串T */
void StrPrint(String T)
{
int i;
for(i=1;i<=T[0];i++)
printf("%c",T[i]);
printf("\n");
}
int main()
{
int i,j;
Status k;
char s;
String t,s1,s2;
printf("请输入串s1: ");
k=StrAssign(s1,"abcd");
if(!k)
{
printf("串长超过MAXSIZE(=%d)\n",MAXSIZE);
exit(0);
}
printf("串长为%d 串空否？%d(1:是 0:否)\n",StrLength(s1),StrEmpty(s1));
StrCopy(s2,s1);
printf("拷贝s1生成的串为: ");
StrPrint(s2);
printf("请输入串s2: ");
k=StrAssign(s2,"efghijk");
if(!k)
{
printf("串长超过MAXSIZE(%d)\n",MAXSIZE);
exit(0);
}
i=StrCompare(s1,s2);
if(i<0)
s='<';
else if(i==0)
s='=';
else
s='>';
printf("串s1%c串s2\n",s);
k=Concat(t,s1,s2);
printf("串s1联接串s2得到的串t为: ");
StrPrint(t);
if(k==FALSE)
printf("串t有截断\n");
ClearString(s1);
printf("清为空串后,串s1为: ");
StrPrint(s1);
printf("串长为%d 串空否？%d(1:是 0:否)\n",StrLength(s1),StrEmpty(s1));
printf("求串t的子串,请输入子串的起始位置,子串长度: ");
i=2;
j=3;
printf("%d,%d \n",i,j);
k=SubString(s2,t,i,j);
if(k)
{
printf("子串s2为: ");
StrPrint(s2);
}
printf("从串t的第pos个字符起,删除len个字符，请输入pos,len: ");
i=4;
j=2;
printf("%d,%d \n",i,j);
StrDelete(t,i,j);
printf("删除后的串t为: ");
StrPrint(t);
i=StrLength(s2)/2;
StrInsert(s2,i,t);
printf("在串s2的第%d个字符之前插入串t后,串s2为:\n",i);
StrPrint(s2);
i=Index(s2,t,1);
printf("s2的第%d个字母起和t第一次匹配\n",i);
SubString(t,s2,1,1);
printf("串t为：");
StrPrint(t);
Concat(s1,t,t);
printf("串s1为：");
StrPrint(s1);
Replace(s2,t,s1);
printf("用串s1取代串s2中和串t相同的不重叠的串后,串s2为: ");
StrPrint(s2);
return 0;
}
下面是Java代码
package impl;
import Interface.IString;
/**
* 定长顺序存储表示串
* <p>
* 用一组地址连续的存储单元存储串值的字符序列
* 在串的定长顺序存储结构中，按照预定义的大小，为每个定义的串变量分配一个固定长度的存储区
* 串的实际长度 可以在定长范围内随意
* <p>
* 定长数组，超出部分自动截断
* <p>
* <p>
* 通俗的说，就是用字符数组来实现字符串
* <p>
* ps:
* 串赋值，串比较,求串长,串连接，求子串(SubString) 这五种操作是最小操作，其他的串操作可以用这五种组合成
*
* 存储密度=串值所占的存储单位/实际分配的存储单位
* 因此 数组型实现的串存储密度大于链表型存储实现的串
*
*
*
*/
public class ArrayString implements IString {
private final int MAXSTRLEN = 10;
private char[] values;
public IString StrAssign(char[] chars) {
int len = chars.length > MAXSTRLEN ? MAXSTRLEN : chars.length;
values = new char[len];
copyArray(values, chars);
return this;
}
public IString StrCopy(IString target) {
target.StrAssign(this.values);
return target;
}
public Boolean StrEmpty() {
if (StrLength() == 0) {
return Boolean.TRUE;
} else {
return Boolean.FALSE;
}
}
public int StrCompare(IString target) {
char[] c2 = target.toArray();
for (int i = 0; i < this.values.length && i < c2.length; i++) {
if (this.values[i] != c2[i]) {
return -1;
}
}
return (this.values.length - c2.length);
}
public int StrLength() {
if (values != null) {
return values.length;
} else {
return 0;
}
}
public Boolean ClearString() {
values = null;
return true;
}
public IString Concat(IString s2) {
int len = StrLength() + s2.StrLength() > MAXSTRLEN ? MAXSTRLEN : StrLength() + s2.StrLength();
char[] charNews = new char[len];
copyArray(charNews, this.values);
char[] cs2 = s2.toArray();
int limit = StrLength() + s2.StrLength() > MAXSTRLEN ? MAXSTRLEN - StrLength() : s2.StrLength();
for (int i = 0; i < limit; i++) {
charNews[StrLength() + i] = cs2[i];
}
IString newS = new ArrayString();
newS.StrAssign(charNews);
return newS;
}
public IString SubString(int pos, int len) {
if (pos < 0 || len + pos - 1 > StrLength()) {
return null; //超出界限
}
char[] c = new char[len];
for (int i = pos; i < len + pos; i++) {
c[i - pos] = values[i - 1];
}
IString s = new ArrayString();
s.StrAssign(c);
return s;
}
public int index(IString T, int pos) {
if (pos + T.StrLength() > StrLength()) {
return 0;
}
for (int i = pos; i < StrLength(); i++) {
if (SubString(i, T.StrLength()).StrCompare(T) == 0) {
return i;
}
}
return 0;
}
public IString Replace(IString T, IString V) {
IString news = this;
int tag = news.index(T, 1);
while (tag != 0) {
news = news.StrDelete(tag, T.StrLength()).StrInsert(V, tag);
tag = news.index(T, tag);
}
return news;
}
public IString StrInsert(IString T, int pos) {
if (pos >= 1) {
int len = StrLength() + T.StrLength() <= MAXSTRLEN ? StrLength() + T.StrLength() : MAXSTRLEN;
char[] newc = new char[len];
char[] inc = T.toArray();
copyArray(newc, values);
//在末尾插入
if (StrLength() < pos && pos < MAXSTRLEN) {
for (int i = 0; i < T.StrLength(); i++) {
newc[pos-1+i] = inc[i];
}
} else {
//挪开位置
for (int i = 0; i <= T.StrLength(); i++) {
newc[len - 1 - i] = newc[StrLength() - 1 - i];
}
//插入新值
for (int i = 0; i < T.StrLength(); i++) {
newc[pos - 1 + i] = inc[i];
}
}
IString news = new ArrayString();
news.StrAssign(newc);
return news;
}
return null;
}
public IString StrDelete(int pos, int len) {
int leng = pos - 1 + len > StrLength() ? pos : StrLength() - len;
char[] c = new char[leng];
copyArray(c, SubString(1, pos - 1).toArray());
IString s = new ArrayString();
if (pos + len > StrLength()) {
s.StrAssign(c);
return s;
} else {
for (int i = 0; i <= leng - pos; i++) {
c[pos - 1 + i] = values[pos + len + i - 1];
}
s.StrAssign(c);
return s;
}
}
public IString DestroyString() {
return null;
}
public void print() {
for (int i = 0; i < values.length; i++) {
System.out.print(values[i]);
}
System.out.println();
}
public char[] toArray() {
char[] c = new char[values.length];
copyArray(c, values);
return c;
}
private void copyArray(char[] target, char[] source) {
for (int i = 0; i < source.length; i++) {
target[i] = source[i];
}
}
}
五、串的链式存储结构
串有必要使用链式存储结构吗？它存放一个字符，还要存放一个指针域，这对空间会造成很大的浪费，串的链式存储结构除了在对字符串进行一些操作的时候有一定的优势，但是总体来说不如顺序存储结构好用，因此，我们就不展开讨论链式存储结构了，感兴趣的可以自己研究一下，和线性表差不多。
六、朴素的模式匹配算法
前面我们已经讲过一个寻找子串的方法Index，这种子串的定位操作通常称做串的模式匹配。
我们从第一个字符串开始往后对比，直到出现这个字符串为之，来实现一个算法
/* 返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数返回值为0。 */
/* 其中,T非空,1≤pos≤StrLength(S)。 */
int Index(String S, String T, int pos)
{
int i = pos; /* i用于主串S中当前位置下标值，从pos位置开始匹配 */
int j = 1; /* j用于子串T中当前位置下标值 */
while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时，循环继续 */
{
if (S[i] == T[j]) /* 两字母相等则继续 */
{
++i;
++j;
}
else /* 指针后退重新开始匹配 */
{
i = i-j+2; /* i退回到上次匹配首位的下一位 */
j = 1; /* j退回到子串T的首位 */
}
}
if (j > T[0])
return i-T[0];
else
return 0;
}
大家有没有发现这个算法有什么弊端吗？如果我们每次匹配对比运气都不好，都是直到最后一个字符才成功匹配到这个子串，如果这个子串和主串都比较长，那么这个算法的运算时间会很长，这在搜索中是不利的，因此我们需要更加高效地模式匹配算法。
七、KMP模式匹配算法
上面说到，那种从第一个字符开始匹配，计算的算法将耗费大量的时间，因此，为解决这个问题，三位前辈研究出了更高效的模式匹配算法，称为克努特-莫里斯-普拉特算法，简称KMP算法。
我们来看上面这个算法，上面这个算法是之间讲的那个朴素的模式匹配算法，但是我们观察一下主串S=“abcdefgab”，子串T=“abcdex”,由于子串的前五个字符和主串的前5个字符都是相同的，并且，子串的第一个字符与后面四个字符都是不相同的，那么，我们再回头去看上面的那个算法是不是从第二步到第五步是没有必要的呢？我们对比完主串的第1个字符后，可以直接跳到第6步开始继续对比。
那如果后面又与头字符相同的字符怎么办呢？例如“abcababca”和子串“abcabx”前五个字符相同，但是相同字符中存在与首字符相同的字符，那么是否也有可以省略的步骤呢？
同样的，子串的首字符并不需要对比对比主串的第二和第三个字符，因此，也是可以省略一些步骤，接下来是由于ab与后面又重复的ab出现，那这一步也是不需要对比的
由以上两种情况我们可以看出来，在对比字符串的时候，通过分析子串是可以省去很多操作的。我们的i值在之前的算法中，i值是通过不断回溯来完成的，但是我们发现这种回溯是可以取消的，KMP模式匹配算法就是为了避免这种回溯出现的，也就是说，i值不会多次回到同一个位置，例如上面的那个例子，i值在进行第一到第六步的时候，i值都回到了6，而我们是不需要这么多次的，经过判断，判断完第一步后，可以直接跳到第六步来进行，因此i值就没有了这个回溯的过程。
因此，i值没有回溯，那我们通过分析子串，来分析j值，字符串“abcdex”中没有与首字母相同的字符，因此j就由6变成了1，而字符串“abcabx”的前缀与后面的ab有两个相同的，因此j就由6变成了3，因此j的取值取决于当前字符之前的串的前后缀的相似度。我们把j的变化值组成一个数组，叫做next。这个next就是匹配退回到的位置。
next数组值的推导，就不展开了，根据上面的讲解可以自己找几组字符串练习一下。
代码实现：
#include "string.h"
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100 /* 存储空间初始分配量 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType; /* ElemType类型根据实际情况而定，这里假设为int */
typedef char String[MAXSIZE+1]; /* 0号单元存放串的长度 */
/* 生成一个其值等于chars的串T */
Status StrAssign(String T,char *chars)
{
int i;
if(strlen(chars)>MAXSIZE)
return ERROR;
else
{
T[0]=strlen(chars);
for(i=1;i<=T[0];i++)
T[i]=*(chars+i-1);
return OK;
}
}
Status ClearString(String S)
{
S[0]=0;/* 令串长为零 */
return OK;
}
/* 输出字符串T。 */
void StrPrint(String T)
{
int i;
for(i=1;i<=T[0];i++)
printf("%c",T[i]);
printf("\n");
}
/* 输出Next数组值。 */
void NextPrint(int next[],int length)
{
int i;
for(i=1;i<=length;i++)
printf("%d",next[i]);
printf("\n");
}
/* 返回串的元素个数 */
int StrLength(String S)
{
return S[0];
}
/* 朴素的模式匹配法 */
int Index(String S, String T, int pos)
{
int i = pos; /* i用于主串S中当前位置下标值，若pos不为1，则从pos位置开始匹配 */
int j = 1; /* j用于子串T中当前位置下标值 */
while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时，循环继续 */
{
if (S[i] == T[j]) /* 两字母相等则继续 */
{
++i;
++j;
}
else /* 指针后退重新开始匹配 */
{
i = i-j+2; /* i退回到上次匹配首位的下一位 */
j = 1; /* j退回到子串T的首位 */
}
}
if (j > T[0])
return i-T[0];
else
return 0;
}
/* 通过计算返回子串T的next数组。 */
void get_next(String T, int *next)
{
int i,k;
i=1;
k=0;
next[1]=0;
while (i<T[0]) /* 此处T[0]表示串T的长度 */
{
if(k==0 || T[i]== T[k])
{
++i;
++k;
next[i] = k;
}
else
k= next[k]; /* 若字符不相同，则k值回溯 */
}
}
/* 返回子串T在主串S中第pos个字符之后的位置。若不存在，则函数返回值为0。 */
/* T非空，1≤pos≤StrLength(S)。 */
int Index_KMP(String S, String T, int pos)
{
int i = pos; /* i用于主串S中当前位置下标值，若pos不为1，则从pos位置开始匹配 */
int j = 1; /* j用于子串T中当前位置下标值 */
int next[255]; /* 定义一next数组 */
get_next(T, next); /* 对串T作分析，得到next数组 */
while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时，循环继续 */
{
if (j==0 || S[i] == T[j]) /* 两字母相等则继续，与朴素算法增加了j=0判断 */
{
++i;
++j;
}
else /* 指针后退重新开始匹配 */
j = next[j];/* j退回合适的位置，i值不变 */
}
if (j > T[0])
return i-T[0];
else
return 0;
}
/* 求模式串T的next函数修正值并存入数组nextval */
void get_nextval(String T, int *nextval)
{
int i,k;
i=1;
k=0;
nextval[1]=0;
while (i<T[0]) /* 此处T[0]表示串T的长度 */
{
if(k==0 || T[i]== T[k]) /* T[i]表示后缀的单个字符，T[k]表示前缀的单个字符 */
{
++i;
++k;
if (T[i]!=T[k]) /* 若当前字符与前缀字符不同 */
nextval[i] = k; /* 则当前的j为nextval在i位置的值 */
else
nextval[i] = nextval[k]; /* 如果与前缀字符相同，则将前缀字符的 */
/* nextval值赋值给nextval在i位置的值 */
}
else
k= nextval[k]; /* 若字符不相同，则k值回溯 */
}
}
int Index_KMP1(String S, String T, int pos)
{
int i = pos; /* i用于主串S中当前位置下标值，若pos不为1，则从pos位置开始匹配 */
int j = 1; /* j用于子串T中当前位置下标值 */
int next[255]; /* 定义一next数组 */
get_nextval(T, next); /* 对串T作分析，得到next数组 */
while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时，循环继续 */
{
if (j==0 || S[i] == T[j]) /* 两字母相等则继续，与朴素算法增加了j=0判断 */
{
++i;
++j;
}
else /* 指针后退重新开始匹配 */
j = next[j];/* j退回合适的位置，i值不变 */
}
if (j > T[0])
return i-T[0];
else
return 0;
}
int main()
{
int i,*p;
String s1,s2;
StrAssign(s1,"abcdex");
printf("子串为: ");
StrPrint(s1);
i=StrLength(s1);
p=(int*)malloc((i+1)*sizeof(int));
get_next(s1,p);
printf("Next为: ");
NextPrint(p,StrLength(s1));
printf("\n");
StrAssign(s1,"abcabx");
printf("子串为: ");
StrPrint(s1);
i=StrLength(s1);
p=(int*)malloc((i+1)*sizeof(int));
get_next(s1,p);
printf("Next为: ");
NextPrint(p,StrLength(s1));
printf("\n");
StrAssign(s1,"ababaaaba");
printf("子串为: ");
StrPrint(s1);
i=StrLength(s1);
p=(int*)malloc((i+1)*sizeof(int));
get_next(s1,p);
printf("Next为: ");
NextPrint(p,StrLength(s1));
printf("\n");
StrAssign(s1,"aaaaaaaab");
printf("子串为: ");
StrPrint(s1);
i=StrLength(s1);
p=(int*)malloc((i+1)*sizeof(int));
get_next(s1,p);
printf("Next为: ");
NextPrint(p,StrLength(s1));
printf("\n");
StrAssign(s1,"ababaaaba");
printf(" 子串为: ");
StrPrint(s1);
i=StrLength(s1);
p=(int*)malloc((i+1)*sizeof(int));
get_next(s1,p);
printf(" Next为: ");
NextPrint(p,StrLength(s1));
get_nextval(s1,p);
printf("NextVal为: ");
NextPrint(p,StrLength(s1));
printf("\n");
StrAssign(s1,"aaaaaaaab");
printf(" 子串为: ");
StrPrint(s1);
i=StrLength(s1);
p=(int*)malloc((i+1)*sizeof(int));
get_next(s1,p);
printf(" Next为: ");
NextPrint(p,StrLength(s1));
get_nextval(s1,p);
printf("NextVal为: ");
NextPrint(p,StrLength(s1));
printf("\n");
StrAssign(s1,"00000000000000000000000000000000000000000000000001");
printf("主串为: ");
StrPrint(s1);
StrAssign(s2,"0000000001");
printf("子串为: ");
StrPrint(s2);
printf("\n");
printf("主串和子串在第%d个字符处首次匹配（朴素模式匹配算法）\n",Index(s1,s2,1));
printf("主串和子串在第%d个字符处首次匹配（KMP算法） \n",Index_KMP(s1,s2,1));
printf("主串和子串在第%d个字符处首次匹配（KMP改良算法） \n",Index_KMP1(s1,s2,1));
return 0;
}
八、KMP改良算法
可以看到上面有一个改良算法，为什么需要改良呢，让我们来看一个例子。如果主串S=“aaaabcde”，子串为T="aaaaax"next数组为012345，计算过程如下。
我们可以发现，2345这几个步骤其实是没用的，j值返回的地方都是a，他与主串的第五个字符b是必然不会相同的，因此我们需要寻找一种方法解决这个问题。
我们可以用第一个字符的next[1]去取代后面与它相同的字符的next值，所以我们对next()函数进行修改。
/* 求模式串T的next函数修正值并存入数组nextval */
void get_nextval(String T, int *nextval)
{
int i,k;
i=1;
k=0;
nextval[1]=0;
while (i<T[0]) /* 此处T[0]表示串T的长度 */
{
if(k==0 || T[i]== T[k]) /* T[i]表示后缀的单个字符，T[k]表示前缀的单个字符 */
{
++i;
++k;
if (T[i]!=T[k]) /* 若当前字符与前缀字符不同 */
nextval[i] = k; /* 则当前的k为nextval在i位置的值 */
else
nextval[i] = nextval[k]; /* 如果与前缀字符相同，则将前缀字符的 */
/* nextval值赋值给nextval在i位置的值 */
}
else
k= nextval[k]; /* 若字符不相同，则k值回溯 */
}
}
意思就是，如果当前字符与前缀字符相同，我们的j值就一直保持初始的状态，这样可以减少一定数量的对比，减少了运算时间。
九、总结
字符串是算法中经常会考到的内容，而且关于字符串的操作有很多，模式匹配算法是其中一种比较重要的算法，我在看的时候花费了大量时间，所以需要根据书本上的图和讲解一起看才能看得懂。
扫一扫
932
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
