数据结构理论基础-4—字符串

Table of Contents

串

串的存储结构

朴素的模式匹配算法

KMP模式匹配算法

KMP模式匹配算法改进

---

C语言具体实现见：数据结构C语言实现-4—字符串

串

串（string）是由零个货多个字符组成的有限序列，又名叫字符串

一般记为：，其中，s 是串的名称，可以是字母、数字或其他字符，i 就是该字符在串中的位置。串的长度为 n。

串的抽象数据类型

ADT串（string）

Data

    串中元素仅有一个字符组成，相邻元素具有前驱和后继关系

Operation

    StrAssign(T, *chars)：生成一个其值等于字符串常量chars的串T

    StrCopy(T, S)：由串S复制得串T

    ClearString(S)：将S清为空串

    StringEmpty(S)：若S为空串，则返回TRUE，否则返回FALSE

    StrLength(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)：用Sub返回串S的第pos个字符起长度为len的子串

    Index(S, T, pos)：返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数返回值为0

    Replace(S, T, V)：用V替换主串S中出现的所有与T相等的不重叠的子串

    StrInsert(S, pos, T)：在串S的第pos个字符之前插入串T

    StrDelete(S, pos, len)：从串S中删除第pos个字符起长度为len的子串

一个操作Index的实现算法

int Index(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 */
}

串的存储结构

串的顺序存储结构

串的顺序存储结构是用一组地址连续的存储单元来存储串中的字符序列的

一般用定长数组来定义，可以将实际的串长度值保存在数组的 0 下标位置，或者加一个不计入串长度的结束标记字符（“\0”）.

                           

串的链式存储结构

串的链式存储结构与线性表相似，但是为了不造成空间的浪费，一个结点可以存放一个字符，也可以存放多个字符

    

朴素的模式匹配算法

串的模式匹配其实就是字串的定位操作（字串在主串中的位置）

例如：从主串S="goodgoogle"中，找到T="google"这个字串的位置

      

    

简单的说，就是对主串的每一个字符作为字串开头，与要匹配的字符串进行匹配，实现代码如下：

/* 返回子串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的长度时，循环继续 */
	{                              /* S[0]，T[0]保存了S和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”， 朴素模式匹配算法的做法如下：

可以看出，T串中的首字符 “a”与T后面的字符均不相等，而图中的第一步操作就判断出前五位相等，这意味着T中的“a”不可能与S串中的第2~5位的字符相等，也就是说，图中的第2、3、4、5步的判断是多余的。

           

朴素的模式匹配算法中，主要是通过主串中 i 值的不断回溯来完成的，而KMP算法就是让这没必要的回溯不发生

i 值不变化，j 值就得变化，我们把T串中各个位置的 j 值变化定义为一个数组next

 next数组值推导

算法实现 

/* 通过计算返回子串T的next数组 */
void get_next(String T, int *next) 
{
	int i,j;
  	i = 1;
  	j = 0;
  	next[1] = 0;
  	while (i < T[0])  /* 此处T[0]表示串T的长度 */
 	{
    	    if(j==0 || T[i]==T[j]) 	/* T[i]表示后缀的单个字符，T[j]表示前缀的单个字符 */
	    {
      	    	++i;  
		++j;  
		next[i] = j;
    	    } 
	    else 
	    	j = next[j];	/* 若字符不相同，则j值回溯 */
      }
}

/* 返回子串T在主串S中第pos个字符之后的位置。若不存在，则函数返回值为0 */
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;
}

KMP模式匹配算法改进

有人发现KMP算法还是有缺陷的，例如，主串S=“aaaabcde”，字串T=“aaaaax”，next的数值分别为012345

可以发现，其中第2345步骤其实是多余的，可以用首位next[1]的值去取代与它相等的字符后续next[j]的值

/* 求模式串T的next函数修正值并存入数组nextval */
void get_nextval(String T, int *nextval)
{
    int i,j;
    i = 1;
    j = 0;
    nextval[1] = 0;
    while(i < T[0])    /* 此处T[0]表示串T的长度 */
    {
        if(j==0 || T[i]==T[j])    /* T[i]表示后缀的单个字符，T[j]表示前缀的单个字符 */
        {
            ++i;
            ++j;
            if(T[i]!=T[j])     /* 若当前字符与前缀字符不同 */
                nextval[i] = j;    /* 则当前的j为nextval在i位置的值 */
            else
                nextval[i] = nextval[j];    /* 如果与前缀字符相同，则将前缀字符的 */
        }                                    /* nextval值赋值给nextval在i位置的值 */
        else
            j = nextval[j];    /* 若字符不相同，则j值回溯 */
    }
}

nextval数组值推导