字符串处理
在网上对于字符串处理的相关介绍很多，这也是各大公司常考的题型，主要是因为在信息处理中，字符串是最常见的结构，这样，字符串作为一种数据结构类型出现在越来越多的程序设计语言中，同时出现了相关的处理字符串的库；如<string.h>，MFC封装的string类CString，以及现在比较流行的BOOST库中的字符串处理算法等等。所以从基本的知识开始，逐步了解基本的字符串操作，也是自己最近对字符串知识了解的总结和备忘。
在本文中通过系统介绍字符串存储结构；字符串处理函数；字符串模式匹配算法。相应的给出代码实现。
字符串处理函数相关资源参考网站：（PS:相应的代码归其作者所有，使用请声明！）
http://blog.csdn.net/v_JULY_v/article/details/6417600
字符串模式匹配算法相关资源参考网站：（PS:相应的代码归其作者所有，使用请声明！）
http://sundful.iteye.com/blog/263847 (KMP详细讲解!）
http://blog.csdn.net/v_july_v/article/details/6545192 (讲解详细!）
http://www.searchtb.com/2011/07/%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%8C%B9%E9%85%8D%E9%82%A3%E4%BA%9B%E4%BA%8B%EF%BC%88%E4%B8%80%EF%BC%89.html
(简洁明了!)
一.字符串结构：
在严蔚敏数据结构书中，将其结构分为：1.定长顺序存储。2.堆分配存储。3.块链存储。4.字典树存储结构(如：键树，Trie树)，树结构存储字符串，主要用于错误单词的处理，这里不做介绍。
二.字符串常规处理函数：（主要是<string.h>中相关函数的实现）
这个的话可以参看string.h中的源码实现。像strstr,strlen,strcpy,strcmp,strcat，以及字符倒置，字符串前(后)移，(或者将这些操作结合一起考察)等基本的字符串操作函数各大公司招聘笔试面试常考的题。其中代码实现见参考连接。其他的操作在平时积累中再添加相应的字符串操作~!
(PS:如果有时间将其用类来封装实现之，待code~~~)
/* 串的定长顺序存储表示 */ #define MAX_STR_LEN 40 /* 用户可在255(1个字节)以内定义最大串长 */ typedef char SString[MAX_STR_LEN+1]; /* 0号单元存放串的长度 */
/* 串的堆分配存储 */
typedef struct
{
char *ch; /* 若是非空串，则按串长分配存储区，否则ch为NULL */
int length; /* 串长度 */
}HString;
/*串的块链存储表示 */
#define CHUNK_SIZE 4 /* 可由用户定义的块大小 */
typedef struct Chunk
{
char ch[CHUNK_SIZE];
struct Chunk *next;
}Chunk;
typedef struct
{
Chunk *head,*tail; /* 串的头和尾指针 */
int curlen; /* 串的当前长度 */
}LString;
三.字符串模式匹配算法： (KMP算法的实现原理参考严蔚敏版本）
1.KMP算法：（时间复杂度：最好O(n/m), 最坏O(n+m)）
模式串与文本串匹配：1.主串无需回溯，而模式串定位到next[j]与s[i]比较继续进行；2.主串与模式串第一个字符匹配，则主串前进下个字符s[i+1]与模式串开始位置继续进行比较匹配。这里关键是next函数的实现。
关于next函数的理论推导：
1.在主串P和模式串S进行匹配时，存在S[i] != P[j]时，则前面字符串满足：P[0...j-1] = S[i-j...i-1]。
2.假设模式串中存在第k+1个字符及P[k]与S[i]正在比较，则前面字符串满足: P[0...k-1] =S[i-k...i-1]。
3.又因为P[j-k...j-1] = S[i-k...i-1], 所以结合上面的条件，推出：P[0...k-1] = P[j-k...j-1]。
于是乎将next函数定义为：（具体推导过程见严蔚敏数据结构书中的介绍P81，很详细~！这里只简单总结备忘)
-1, 当j=0时
next[j] = Max{k|0<k<j,且P[0...k-1]=P[j-k...j-1]} 当此集合不为空时。
0, 其他情况
next函数的实现参考严蔚敏数据结构书中的介绍P83，是一个递推的推导过程（备忘）
KMP算法最大的特点是指示主主串的指针不需要回溯，整个匹配过程中，对主串仅需要从头到尾扫描一遍，这对处理从外设输入的庞大文件很有效，可以边读入边匹配，而无需回头重读。
2.BM算法：（时间复杂度：最好O(n/(m+1)), 最坏O(n*m)?）
后缀匹配，是指模式串的比较从右到左，模式串的移动也是从左到右的匹配过程，经典的BM算法其实是对后缀蛮力匹配算法的改进。为了实现更快移动模式串，BM算法定义了两个规则，坏字符规则和最好后缀规则，分别得到坏字符表和最好后缀表。利用好后缀和坏字符可以大大加快模式串的移动距离。
BM算法则综合坏字符表和最好后缀表,模式串定位位到母串给定位置,移动的最大值。
字符串模式匹配算法实现代码：（代码归其作者所有，使用请声明~！）
/*===============================================================================
@editor:weedge
@date:2011/08/08
@comment:
字符串模式匹配算法：
1.前缀蛮力匹配，
2.优化得到KMP算法（主串无需回溯，而模式串定位到p[next[j]]位置与s[i]继续匹配比较），模式串的比较从左到右，模式串的移动是从左到右的匹配过程。
3.后缀缀蛮力匹配，
4.以及坏字规则匹配，
5.最好后缀规则匹配，
6.最后综合2者得到BM算法，模式串的比较从右到左，模式串的移动也是从左到右的匹配过程。
相关资源参考网站：（PS:相应的代码归其作者所有，使用请声明！）
http://blog.csdn.net/v_july_v/article/details/6545192 （介绍详细）
http://www.searchtb.com/2011/07/%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%8C%B9%E9%85%8D%E9%82%A3%E4%BA%9B%E4%BA%8B%EF%BC%88%E4%B8%80%EF%BC%89.html （简洁明了）
================================================================================*/
#include <iostream>
using namespace std;
#define NEXT
//=========================前缀蛮力匹配O(M*N)========================================
/*======================================================================
前缀蛮力匹配算法的代码（以下代码从linux源码string.h中抠出），
模式串和母串的比较是从左到右进行（strncmp()），
如果找不到和模式串相同的子串，则从左到右移动模式串，距离为1（s++）。
=========================================================================*/
char* str_str(register const char *s, register const char *p)
{
register size_t len = strlen(p);
if (len==0) return (char*)s;
while(*s!=*p || strncmp(p,s,len))
{//首字母不相等，或者首字母相等，但是整个字符串不相等，那么母串中下个字符开始再进行匹配，即模式串从左向右移动一位。
if (*s++ == '\n')
{
return (char*) NULL;
}
}
return (char*)s;
}
/*=============================================================
int search_forward(char const*, int, char const*, int)(严蔚敏版本)
查找出模式串patn在主串src中第一次出现的位置
plen为模式串的长度
返回patn在src中出现的位置，当src中并没有patn时，返回-1
=============================================================*/
int search_forward(char const* src, int slen, char const* patn, int plen)
{
int i = 0, j = 0;
while( i < slen && j < plen )
{
if( src[i] == patn[j] ) //如果相同，则两者++，继续比较
{
++i;
++j;
}
else
{
//否则，指针回溯，重新开始匹配
i = i - j + 1; //退回到最开始时比较的位置
j = 0;
}
}
if( j >= plen )
return i - plen; //如果字符串相同的长度大于模式串的长度，则匹配成功
else
return -1;
}
//===========================================KMP O(M+N) 最好：O(N),最坏：O(N/M)==================================================
/*==================================================================
求next数组各值的函数：
(严蔚敏版本改版,严蔚敏版本是从数组下标1开始，而数组下标0中的数为字符串长度)
其next函数定义如下：
-1, 当j=0时
next[j] = Max{k|0<k<j,且P[0...k-1]=P[j-k...j-1]} 当此集合不为空时。
0, 其他情况
======================================================================*/
void get_next(char const* ptrn, int plen, int* nextval)
{
int i = 0;
nextval[i] = -1;
int j = -1;
while( i < plen-1 )
{
if( j == -1 || ptrn[i] == ptrn[j] ) //循环的if部分
{
++i;
++j;
nextval[i] = j;
}
else //循环的else部分
j = nextval[j];
}
}
/*==================================================================
修正后的求next数组各值的函数：
======================================================================*/
void get_nextval(char const* ptrn, int plen, int* nextval)
{
int i = 0;
nextval[i] = -1;
int j = -1;
while( i < plen-1 )
{
if( j == -1 || ptrn[i] == ptrn[j] ) //循环的if部分
{
++i;
++j;
//修正的地方就发生下面这4行
if( ptrn[i] != ptrn[j] ) //++i，++j之后，再次判断ptrn[i]与ptrn[j]的关系
nextval[i] = j; //之前的错误解法就在于整个判断只有这一句。
else //后面出现相同的字符可以直接跳过，所以next赋值等于前面的next值。
nextval[i] = nextval[j];
}
else //循环的else部分
j = nextval[j];
}
}
/*===================================================================
int KMPSearch(char const*, int, char const*, int, int const*, int pos)
KMP模式匹配函数:(严蔚敏版本改版)
输入：src, slen主串
输入：patn, plen模式串
输入：nextval KMP算法中的next函数值数组
输出：成功返回位置，否则为-1
===============================================================*/
int KMPSearch(char const* src, int slen, char const* patn, int plen, int const* nextval, int pos)
{
int i = pos;
int j = 0;
while ( i < slen && j < plen )
{
if( j == -1 || src[i] == patn[j] )
{
++i;
++j;
}
else
{
j = nextval[j];
//当匹配失败的时候直接用p[j_next]与s[i]比较，而母串无需回溯。
}
}
if( j >= plen )
return i-plen;
else
return -1;
}
//===========================后遍历蛮力匹配O(M*N)=======================================
/*==========================================================
int search_reverse(char const*, int, char const*, int)
模式串的比较从右到左，模式串的移动也是从左到右的匹配过程
成功返回位置，否则为-1
=========================================*/
int search_reverse(char const* src, int slen, char const* patn, int plen)
{
int s_idx = plen, p_idx;
if (plen == 0)
return -1;
while (s_idx <= slen)//计算字符串是否匹配到了尽头
{
p_idx = plen;
while (src[--s_idx] == patn[--p_idx])//开始匹配
{
//if (s_idx < 0)
//return -1;
if (p_idx == 0)
{
return s_idx;
}
}
s_idx += (plen - p_idx)+1; //主串位置s_idx向后回溯plen-p_index+1位到比较前的下个位置，相当于模式串从左向右移动一位。
}
return -1;
}
//==========================BM 最好：O(N/M)， 最坏:O(M*N)================================
/*=============================================================
函数：void BuildBadCharacterShift(char *, int, int*)
目的：根据好后缀规则做预处理，建立一张好后缀表shift[256]（字符所表示的范围：0-255）
参数：
pattern => 模式串P
plen => 模式串P长度
shift => 存放坏字符规则表,长度为的int数组
返回：void
=======================================================================*/
void BuildBadCharacterShift(char const* pattern, int plen, int* shift)
{
for( int i = 0; i < 256; i++ )
*(shift+i) = plen;
while ( plen >0 )
{
*(shift+(unsigned char)*pattern++) = --plen;
}
}
/*=============================================================
search_badcharacter函数：采用坏字规则（坏字表）来查找出模式串patn在主串src中第一次出现的位置
这里出现两种情况：
1.坏字符没出现在模式串中，这时可以把模式串移动到坏字符的下一个字符，继续比较。
2.坏字符出现在模式串中，这时可以把模式串第一个出现的坏字符和母串的坏字符对齐，当然，这样可能造成模式串倒退移动。
return patn在src中出现的位置，当src中并没有patn时，返回-1
具体参考：
http://www.searchtb.com/2011/07/%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%8C%B9%E9%85%8D%E9%82%A3%E4%BA%9B%E4%BA%8B%EF%BC%88%E4%B8%80%EF%BC%89.html#comment-627
==============================================================*/
int search_badcharacter(char const* src, int slen, char const* patn, int plen, int* shift)
{
int s_idx = plen, p_idx;
int skip_stride;
if (plen == 0)
return -1;
while (s_idx <= slen)//计算字符串是否匹配到了尽头
{
p_idx = plen;
while (src[--s_idx] == patn[--p_idx])//开始匹配
{
//if (s_idx < 0)
//Return -1;
if (p_idx == 0)
{
return s_idx;
}
}
skip_stride = shift[(unsigned char)src[s_idx]];
s_idx += (skip_stride>plen-p_idx ? skip_stride: plen-p_idx)+1;
}
return -1;
}
/*=================================================================
函数：void BuildGoodSuffixShift(char *, int, int*)
目的：根据最好后缀规则做预处理，建立一张好后缀表（这个貌似有点难度）
参数：
pattern => 模式串P
plen => 模式串P长度
shift => 存放最好后缀表数组
返回：void
具体参考：
http://blog.csdn.net/v_july_v/article/details/6545192
==============================================================*/
void BuildGoodSuffixShift(char const* pattern, int plen, int* shift)
{
shift[plen-1] = 1; // 右移动一位
char end_val = pattern[plen-1];
char const* p_prev, const* p_next, const* p_temp;
char const* p_now = pattern + plen - 2; // 当前配匹不相符字符,求其对应的shift
bool isgoodsuffixfind = false; // 指示是否找到了最好后缀子串,修正shift值
for( int i = plen -2; i >=0; --i, --p_now)
{
p_temp = pattern + plen -1;
isgoodsuffixfind = false;
while ( true )
{
while (p_temp >= pattern && *p_temp-- != end_val); // 从p_temp从右往左寻找和end_val相同的字符子串
p_prev = p_temp; // 指向与end_val相同的字符的前一个
p_next = pattern + plen -2; // 指向end_val的前一个
// 开始向前匹配有以下三种情况
//第一：p_prev已经指向pattern的前方,即没有找到可以满足条件的最好后缀子串
//第二：向前匹配最好后缀子串的时候,p_next开始的子串先到达目的地p_now,
//需要判断p_next与p_prev是否相等,如果相等,则继续住前找最好后缀子串
//第三：向前匹配最好后缀子串的时候,p_prev开始的子串先到达端点pattern, 这个可以算是最好的子串
if( p_prev < pattern && *(p_temp+1) != end_val ) // 没有找到与end_val相同字符
break;
bool match_flag = true; //连续匹配失败标志
while( p_prev >= pattern && p_next > p_now )
{
if( *p_prev --!= *p_next-- )
{
match_flag = false; //匹配失败
break;
}
}
if( !match_flag )
continue; //继续向前寻找最好后缀子串
else
{
//匹配没有问题, 是边界问题
if( p_prev < pattern || *p_prev != *p_next)
{
// 找到最好后缀子串
isgoodsuffixfind = true;
break;
}
// *p_prev == * p_next 则继续向前找
}
}
shift[i] = plen - i + p_next - p_prev;
if( isgoodsuffixfind )
shift[i]--; // 如果找到最好后缀码，则对齐，需减修正
}
}
/*==============================================================
search_goodsuffix：
采用最好后缀匹配规则（利用最好后缀表）来查找出模式串patn在主串src中第一次出现的位置
如何根据好后缀规则移动模式串，shift（好后缀）分为三种情况：
1.模式串中有子串匹配上好后缀，此时移动模式串，让该子串和好后缀对齐即可，如果超过一个子串匹配上好后缀，则选择最靠左边的子串对齐。
2.模式串中没有子串匹配上后后缀，此时需要寻找模式串的一个最长前缀，并让该前缀等于好后缀的后缀，寻找到该前缀后，让该前缀和好后缀对齐即可。
3.模式串中没有子串匹配上后后缀，并且在模式串中找不到最长前缀，让该前缀等于好后缀的后缀。此时，直接移动模式到好后缀的下一个字符。
return patn在src中出现的位置，当src中并没有patn时，返回-1
具体参考：
http://www.searchtb.com/2011/07/%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%8C%B9%E9%85%8D%E9%82%A3%E4%BA%9B%E4%BA%8B%EF%BC%88%E4%B8%80%EF%BC%89.html#comment-627
========================================================================================*/
int search_goodsuffix(char const* src, int slen, char const* patn, int plen, int* shift)
{
int s_idx = plen, p_idx;
int skip_stride;
if (plen == 0)
return -1;
while (s_idx <= slen)//计算字符串是否匹配到了尽头
{
p_idx = plen;
while (src[--s_idx] == patn[--p_idx])//开始匹配
{
//if (s_idx < 0)
//return -1;
if (p_idx == 0)
{
return s_idx;
}
}
skip_stride = shift[p_idx];
s_idx += skip_stride +1;
}
return -1;
}
/*========================================================================
函数：int* BMSearch(char *, int , char *, int, int *, int *)
目的：判断文本串T中是否包含模式串P
说明：综合坏字符表bad_shift和最好后缀表good_shift,模式串定位位到母串给定位置,移动的最大值。
参数：
src => 文本串T
slen => 文本串T长度
ptrn => 模式串P
pLen => 模式串P长度
bad_shift => 坏字符表
good_shift => 最好后缀表
返回：
int - 1表示匹配失败，否则返回位置
================================================*/
int BMSearch(char const*src, int slen, char const*ptrn, int plen, int const*bad_shift, int const*good_shift)
{
int s_idx = plen;
if (plen == 0)
return 1;
while (s_idx <= slen)//计算字符串是否匹配到了尽头
{
int p_idx = plen, bad_stride, good_stride;
while (src[--s_idx] == ptrn[--p_idx])//开始匹配
{
//if (s_idx < 0)
//return -1;
if (p_idx == 0)
{
return s_idx;
}
}
// 当匹配失败的时候，向前滑动
bad_stride = bad_shift[(unsigned char)src[s_idx]]; //根据坏字符规则计算跳跃的距离
good_stride = good_shift[p_idx]; //根据好后缀规则计算跳跃的距离
s_idx += ((good_stride > bad_stride) ? good_stride : bad_stride )+1;//取大者
}
return -1;
}
int main()
{
char *strS = "ababcabcacbab";
char *strP = "abcac";
/*test str_str*/
cout<<"/*test str_str*/"<<endl;
cout<<str_str(strS,strP)<<endl;
/*test search_forward*/
cout<<"/*test search_forward*/"<<endl;
cout<<search_forward(strS,strlen(strS),strP,strlen(strP))<<endl;
/*test KMPSearch*/
cout<<"/*test KMPSearch*/"<<endl;
int *nextval = new int[strlen(strP)];
#ifdef NEXT
get_next(strP,strlen(strP),nextval);
cout<<"get_next:"<<endl;
#else
get_nextval(strP,strlen(strP),nextval);
cout<<"get_nextval:"<<endl;
#endif
int i;
for (i=0; i<strlen(strP); i++)
{
cout<<nextval[i]<<" ";
}
cout<<endl;
int kmp = KMPSearch(strS,strlen(strS),strP,strlen(strP),nextval,0);//主串从开始位置进行查找匹配。
cout<<kmp<<endl;
delete []nextval;
/*test search_reserve*/
cout<<"/*test search_reserve*/"<<endl;
cout<<search_reverse(strS,strlen(strS),strP,strlen(strP))<<endl;
/*test search_badcharacter*/
cout<<"/*test search_badcharacter*/"<<endl;
int *BadCharacterShift = new int[1<<8];//一个字符8位,2^8.
BuildBadCharacterShift(strP,strlen(strP),BadCharacterShift);
cout<<"BuildBadCharacterShift:"<<endl;
char *strTemp = strP;
for (i=0; i<strlen(strP); i++)
{
cout<<*(BadCharacterShift + (unsigned char)*strTemp++)<<" ";
}
cout<<endl;
int bc = search_badcharacter(strS,strlen(strS),strP,strlen(strP),BadCharacterShift);
cout<<bc<<endl;
//delete []BadCharacterShift;
/*test search_goodsuffix*/
cout<<"/*test search_goodsuffix*/"<<endl;
int *GoodSuffixShift = new int[strlen(strP)];
BuildGoodSuffixShift(strP,strlen(strP),GoodSuffixShift);
cout<<"BuildGoodSuffixShift:"<<endl;
for (i=0; i<strlen(strP); i++)
{
cout<<GoodSuffixShift[i]<<" ";
}
cout<<endl;
int gs = search_goodsuffix(strS,strlen(strS),strP,strlen(strP),GoodSuffixShift);
cout<<gs<<endl;
//delete []GoodSuffixShift;
/*test BMSearch*/
cout<<"/*test BMSearch*/"<<endl;
int bm = BMSearch(strS,strlen(strS),strP,strlen(strP),BadCharacterShift,GoodSuffixShift);
cout<<bm<<endl;
delete []BadCharacterShift;
delete []GoodSuffixShift;
system("pause");
return 0;
}