1. 字符串与子串、子序列
字符串是由零个或多个字符组成的有限串行,子串的定义是串中任意个连续的字符组成的子序列,并规定空串是任意串的子串,任意串是其自身的子串,
2. C风格字符串
C++ 语言通常通过char*/const char*类型的指针来C语言中的风格字符串。一般来说,我们使用指针的算数操作符来遍历C风格字符串,每次对指针进行测试并递增1,直到到达字符串null为止。
3. 标准库提供的字符串处理函数
C++提供了众多的字符串处理函数,主要如下:
1)Strlen
Strlen计算字符数组的字符数,以’\0’为结束标志,计算不为’\0’的元素的个数。
自定义函数实现strlen的功能是:
Int strlen(const char * str)
{
Assert(strlen != NULL);
Int len = 0;
While((*str++) != ‘\0’))
Len++;
Return len;
}
2)Strcmp
即两个字符串自左向右逐个字符比较(按ASCALL 值的大小比较),直到出现不同的字符或遇’\0’为止。若s1与s2相等,返回0;若s1大于s2,返回正数,若s1小于s2,则返回负数。
自定义实现strcmp函数的功能:
Int strcmp(const char * str1, const char * str2)
{
Assert(str1 != NULL && str2 != NULL);
While(!(ret =*(unsigned char* )str1 - *(unsigned char*)str2 ) && *str1)
{
Str1++;
Str2++;
}
If(ret<0)
Ret = -1;
Else if(ret > 0)
Rer = 1;
Return ret;
}
3)Strcat与strcpy
Strcat(dest, src)把所指字符串添加到dest结尾处(覆盖dest结尾处的’\0’)并添加’\0’;
Strcpy(dest, src)把从src开始且含有null结束符的字符串复制到以dest开始的地址空间。
传递给标准库函数strcat和strcpy的第一个参数数组必须具有足够大的空间存放新生的字符串。
自定义函数实现strcat函数的功能:
Char * strcat(char * strDest, const char * strSrc )
{
Char * address = strDest;
Assert((strDest != NULL)&&(strcat != NULL));
While(*srcDest)
srcDest++;
While(*strDest++ = *strSrc++)
Return address;
}
自定义函数实现strcpy()函数的功能:
Char* strcpy(char * strDestination, const char * strSource)
{
Assert((strdestination != NULL) && (strSource != NULL));
Char *strD = strdestination;
While((*strdestination++ = *strsource++) != ‘\0’) ;
Return strD;
}
4)memcpy 与 memset
Memcpy函数
Void * memcpy(void * dest, const void *src, size_t n);
功能:从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中,函数返回指向dest的指针。
Strcpy与memcpy的比较
1)复制的内容不同,前者只能复制字符串,后者可以复制任意内容。
2)复制方法不同,前者不用指定长度,遇到被复制的字符串结束符’\0’时才结束,容易溢出,后者则是根据其第三个参数决定复制的长度。
3)用途不同,通常复制字符串时用strcpy,而复制其它类型字符时用memcpy;
Memset函数
Void* memset(void *s , int ch, size_t n);
功能:作用是将s中前n个字节用ch替换并返回s,作用是在一块内存中填充某个给定的值,他是对较大的结构体或数组进行清零操作的一种最快方法。
4.字符串的实际应用
1)字符串包含问题
可以用两种方法解决,第一种是串的模式匹配算法,第二种是KMP算法
如:给定一个字符串A,要求在A中查找一个子串B。
深入串的模式匹配算法(普通算法和KMP算法)的详解
串的定位操作通常称作串的模式匹配,是各种处理系统中的最重要操作之一。
模式匹配最朴素的算法是回溯法,即模式串跟主串一个字符一个字符的匹配,当模式串中跟主串不匹配时,主串回溯到与模式串匹配开始的下一个位置,模式串回溯到第一个位置,继续匹配。算法的时间复杂度为O(m*n),算法如下:
//朴素的串的模式匹配算法,S为主串,T为模式串,即找S中有没有与T相同的字串
int Index(char *S, char *T, int pos)//pos记录从哪一位开始匹配可以直接用0代替
{
int i=pos, j=0;
while(i <strlen(S) && j <strlen(T))//确保未超出字符串的长度
{
if (S[i] == T[j])
{ ++i; ++j;} //如果相同,则继续向后比较
else
{i = i-j+1; j =0;} //如果不同,就回溯,重新查找
}
if (j == strlen(T))
return i-strlen(T); //若匹配成功,返回S中与T字符串相同开始位置的索引
else return 0; //若匹配不成功,返回0
}
O(m*n)的时间复杂度有点大,于是人们发现了KMP算法,核心思想是:当不匹配发生时,主串不回溯,模式串回溯到“合适”的位置,哪个位置合适,只与模式串有关,所以可以先算出模式串中各个字符,当不匹配发生是,应该回溯到哪个位置。算法整体时间复杂度O(m+m)。
void GetNext(char* T, int *next)
{
int i=1,j=0;
next[1]=0;
while( i < strlen(T) )
{
if (j == 0 || T[i] == T[j])
{
++i; ++j;
next[i] = j;
}
else j = next[j];
}
}
int KMP(char* S, char* T, int pos)
{
int i = pos, j = 1;
while (i)
{
if (S[i] == T[j])
{
++ i; ++ j;
}
else
j = next[j];
}
if (j > strlen(T))
return i-T[0];
else
return 0;
}
求next的操作不是最优的,因为他没有考虑aaaaaaaaaaaaaaaaaaab的情况,这样前面会出现大量的1,这样的算法复杂度已经和最初的朴素算法没有区别了。所以稍微改动一下:
void GetNextEx(char *T, int *next)
{
int i=1,j=0; next[1] = 0;
while(i < strlen(T))
{
if (j == 0 || T[i] == T[j])
{
++i; ++j;
if (T[i] == T[j])
next[i] = next[j]; //减少回退次数
else next[i] = j; //和上面算法一样next[i]=j
}
else j = next[j];
}
}
2)字符串移位包含问题 (略)