第5天串

1  串的抽象数据类型的定义

2  串的表示和实现

3  串的模式匹配算法 

 

串，是由零个或多个字符组成的有限序列．                           

如: 'a string'   一般记为Ｓ＝’a1a2…an’ (n>=0) 其中Ｓ是串的名称，

用’’括起来的字符序列是串的值；         

字符个数n称为串的长度．         

零个字符的串称为空串用来表示，长度为零．        

由一个或多个空格组成的串称为空格串． 

 

 

串中任意个连续的字符组成的子序列称为该串的子串．         

包含子串的串相应地称为主串．         

通常称字符在序列中的序号为该字符在串中的位置．         

子串在主串中的位置则以子串的第一个字符在主串中的位置来表示．

 

例如： S ='abcaabcaaabc',  T = 'bca'  

 

串的逻辑结构和线性表极为相似，区别 仅在于串的数据对象约束为字符集。

 

串的基本操作和线性表有很大差别

 

在线性表的基本操作中，大多以“单个元素”作为操作对象；     

在串的基本操作中，通常以“串的整体”作为操作对象。 

 

4.1  串的抽象数据类型的定义如下：

 

ADT String {

 数据对象：D＝{ ai |ai∈CharacterSet,          i=1,2,...,n,       n≥0 }

 数据关系：R1＝{ < ai-1, ai > | ai-1, ai ∈D,    i=2,...,n }

 基本操作：

StrAssign (&T, chars)

DestroyString(&S)

StrCopy (&T, S)

StrLength(S)

StrCompare (S, T)

Concat (&T, S1, S2)

StrEmpty (S) 

SubString (&Sub, S, pos, len) 

ClearString (&S)

Index (S, T, pos) 

Replace (&S, T, V) 

StrInsert (&S, pos, T) 

StrDelete (&S, pos, len) 

} ADT String 

 

  StrAssign (&T, chars)    初始条件：chars 是字符串常量。   操作结果：把 chars 赋为 T 的值。

  StrCopy (&T, S)            初始条件：串 S 存在。       操作结果：由串 S 复制得串 T

  StrCompare(S,T)           初始条件：  串S和T存在。 操作结果：  若S> T，则返回值 > 0；若S < T，则返回值 < 0； 若S = T，则返回值 = 0。

                                      例如：StrCompare('data', 'state') < 0             StrCompare('cat', 'case') > 0

  StrLength(S) 初始条件：串 S 存在。 操作结果：返回 S 的元素个数，  称为串的长度。 

  Concat(&T,S1,S2)(concatenation) 初始条件：串 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。

 

  StrDelete (&S, pos, len)初始条件：串S存在 1≤pos≤StrLength(S)-len+1。操作结果：从串S中删除第pos个字符起长度为len的子串。

  ClearString(&S)  初始条件：串S存在。  操作结果：将S清为空串。

 

  对于串的基本操作集可以有不同的定义方法，在使用高级程序设计语言中的串类型时，应以该语言的参考手册为准。 

 

例如：C语言函数库中提供下列串处理函数：

gets(str)  输入一个串；  

puts(str) 输出一个串；  

strcat(str1, str2)  串联接函数； 

strcpy(str1, str2, k)  串复制函数； 

strcmp(str1, str2)  串比较函数；  

strlen(str)  求串长函数； 

 

在上述抽象数据类型定义的13种操作中，  

串赋值StrAssign、串复制Strcopy、  

串比较StrCompare、求串长StrLength、  

串联接Concat以及求子串SubString  等六种操作构成串类型的最小操作子集。  

即：这些操作不可能利用其他串操作来实现，  反之，其他串操作（除串清除ClearString和串  销毁DestroyString外）可在这个最小操作子  集上实现。 

 

  例如，可利用串比较、求串长和求子串等操作实现定位函数Index(S,T,pos)。 

 

 

int Index (String S, String T, int pos) {  
    // T为非空串。若主串S中第pos个字符之后存在与 T相等的子串， 则返回第一个这样的子串在S中的位置，否则返回0  
    if (pos > 0) {    
        n = StrLength(S);  m = StrLength(T);  i = pos;    
        while ( i <= n-m+1) {        
        SubString (sub, S, i, m);       
             if (StrCompare(sub,T) != 0)   ++i ;       
             else return i ;    } // while  
         } // if  return 0;      // S中不存在与T相等的子串 
    } // Index 

 

 

 

4.2  串的表示和实现

在程序设计语言中，串只是作为输入或输出的常量出现，则只需存储此串的串值，即字符序列即可。但在多数非数值处理的程序中，串也以变量的形式出现。

一、串的定长顺序存储表示

二、串的堆分配存储表示

三、串的块链存储表示

 

一、串的定长顺序存储表示

#define  MAXSTRLEN  255        
// 用户可在255以内定义最大串长  
typedef unsigned char  Sstring   [MAXSTRLEN + 1];                               
 // 0号单元存放串的长度

 

特点:

串的实际长度可在这个予定义长度的范围内随意设定，超过予定义长度的串值则被舍去，称之为 “截断” 。

按这种串的表示方法实现的串的运算时，其基本操作为 “字符序列的复制”。

int Index (String S, String T, int pos) {
 // T为非空串。若主串S中第pos个字符之后存在与 T相等的子串，
  则返回第一个这样的子串在S中的位置，否则返回0
  if (pos > 0) {
    n = StrLength(S);  m = StrLength(T);  i = pos;
    while ( i <= n-m+1) {
        SubString (sub, S, i, m);
        if (StrCompare(sub,T) != 0)   ++i ;
        else return i ;
    } // while
  } // if  return 0;          // S中不存在与T相等的子串
} // Index

//串的联接算法中需分三种情况处理：

Status Concat(SString S1, SString S2, SString &T) 
   {// 用T返回由S1和S2联接而成的新串。若未截断, 则返回TRUE，否则FALSE。
  if (S1[0]+S2[0] <= MAXSTRLEN) {// 未截断
     T[1..S1[0]] = S1[1..S1[0]];
     T[S1[0]+1..S1[0]+S2[0]] = S2[1..S2[0]];
     T[0] = S1[0]+S2[0];   uncut = TRUE;      }
 
   else if (S1[0] <MAXSTRSIZE) { // 截断
     T[1..S1[0]] = S1[1..S1[0]];
     T[S1[0]+1..MAXSTRLEN] = S2[1..MAXSTRLEN－S1[0]];           
     T[0] = MAXSTRLEN;     uncut = FALSE;  }
 
    else { // 截断(仅取S1) 
    T[0..MAXSTRLEN] = S1[0..MAXSTRLEN];
     // T[0] == S1[0] == MAXSTRLEN
    uncut = FALSE;           }
    }

二、串的堆分配存储表示

//串的堆分配存储表示
typedef struct {
   char *ch;     
      // 若是非空串，则按串长分配存储区，
      //  否则ch为NULL
   int  length;   // 串长度
 } HString;

 通常，C语言中提供的串类型就是以这种存储方式实现的。

系统利用函数malloc( )和free( )进行串值空间的动态管理，为每一个新产生的串分配一个存储区，称串值共享的存储空间为“堆”。        

C语言中的串以一个空字符为结束符， 串长是一个隐含值。

这类串操作实现的算法为：    先为新生成的串分配一个存储空间，然后  进行串值的复制。

Status Concat(HString &T, HString S1, HString S2)
{ // 用T返回由S1和S2联接而成的新串
      if (T.ch)  free(T.ch);        // 释放旧空间
      if (!(T.ch = (char *)malloc((S1.length+S2.length)*sizeof(char))))
         exit (OVERFLOW);
      T.ch[0..S1.length-1] = S1.ch[0..S1.length-1];
      T.length = S1.length + S2.length;
      T.ch[S1.length..T.length-1] = S2.ch[0..S2.length-1];
      return OK;
} // Concat

Status SubString(HString &Sub, HString S,int pos, int len)
 { // 用Sub返回串S的第pos个字符起长度为len的子串
      if (pos < 1  ||  pos > S.length  ||  len < 0  ||  len > S.length-pos+1)  
          return ERROR;
      if (Sub.ch)  free (Sub.ch);             // 释放旧空间
      if (!len){ Sub.ch = NULL;  Sub.length = 0; } // 空子串
      else {   Sub.ch = (char *)malloc(len*sizeof(char));
               Sub.ch[0..len-1] = S[pos-1..pos+len-2];
               Sub.length = len;
           } // 完整子串
      return OK;
} // SubString

三、串的块链存储表示

也可用链表来存储串值，由于串的数据元素是一个字符，它只有 8 位二进制数，因此用链表存储时，通常一个结点中存放的不是一个字符，而是一个子串。

存储密度小，运算处理方便，然而，存储量占用大。

 

#define  CHUNKSIZE  80  // 块的大小
  typedef  struct Chunk {  // 结点结构
    char  ch[CUNKSIZE];
    struct Chunk  *next;
  } Chunk;
  typedef struct {  // 串的链表结构
    Chunk *head, *tail; // 串的头和尾指针
     int   curlen;     // 串的当前长度
  } LString;   

 

实际应用时，可以根据问题所需来设置结点的大小

例如: 在编辑系统中，整个文本编辑区可以看成是一个串，每一行是一个子串，构成一个结点。即: 同一行的串用定长结构(80个字符),   行和行之间用指针相联接。

串值的链式存储结构对某些串操作如联接操作等有一定方便之处，但总的说来不如另外两种存储结构。 

4.3 串的模式匹配算法

这是串的一种重要操作，很多  软件，若有“编辑”菜单项的话，  则其中必有“查找”子菜单项。

首先，回忆一下串匹配(查找)的定义:

INDEX (S, T, pos)

初始条件：串S和T存在，T是非空串，                     

 1≤pos≤StrLength(S)。 

操作结果：若主串S中存在和串T值相 同的子串，返回它在主串S中从第pos个字符开始第一次出现的位置；否则函数 返回值为0。    

 

下面讨论以定长顺序结构表示串时的几种算法。

一、简单算法

二、首尾匹配算法

三、KMP(D.E.Knuth, V.R.Pratt, J.H.Morris) 算法

 

一、简单算法 

int Index(SString S, SString T, int pos) {
   // 返回子串T在主串S中第pos个字符之后的位置。若不存在，
    // 则函数值为0。其中，T非空，1≤pos≤StrLength(S)。
    i = pos;   j = 1;
    while (i <= S[0] && j <= T[0]) {
      if (S[i] == T[j]) { ++i;  ++j; }   // 继续比较后继字符
      else { i = i-j+2;   j = 1; }     // 指针后退重新开始匹配
    }
   if (j > T[0])  return  i-T[0];
   else return 0;
} // Index
 
while (i <= S[0] && j <= T[0])
  { if (S[i] == T[j]) { ++i;  ++j; }   // 继续比较后继字符      
   else { i = i-j+2;   j = 1; } // 指针后退重新开始匹配 }

 

 

 

i＝i的原位置＋1  ＝i－（j移动的长度）＋1  

                         ＝i－(j－1)＋1  

                         ＝i－j＋2 

二、首尾匹配算法

先比较模式串的第一个字符，   再比较模式串的最后一个字符，      

最后比较模式串中从第二个到 第n-1个字符。

int Index_FL(SString S, SString T, int pos) {
    sLength = S[0];  tLength = T[0];
    i = pos; 
    patStartChar = T[1];  patEndChar = T[tLength];
   while (i <= sLength – tLength + 1) {
     if (S[i] != patStartChar) ++i;  //重新查找匹配起始点
     else  if (S[i+tLength-1] != patEndChar) ++i; 
                                             // 模式串的“尾字符”不匹配
     else { k = 1;  j = 2;
            while ( j < tLength && S[i+k] == T[j])
            { ++k;   ++j; } 
            if ( j == tLength )  return i;
            else  ++i;   
             // 重新开始下一次的匹配检测                                
            }
   }
   return 0;
  }

    一般情况下简单算法的时间复杂度为Ｏ(n+m)。但 主串为  `000000000000000000000000000000001` 模式串为`0000001`时，经常发生匹配到模式串的最后一个字符时，主串指针回溯的现象，导致用 简单算法时最坏情况下时间复杂度为Ｏ(n*m)。 改进后的算法思想是：主串指针不回溯，而将模式串滑到尽可能远的一段距离之后（即选择模式串中的某个字符）继续进行比较。 需要解决的问题是：失配时，主串中第i个字符与模式串中的哪个字符再比较

 

三、KMP(D.E.Knuth克努特, J.H.Morris 莫里斯 V.R.Pratt,普拉特) 算法 

KMP算法的时间复杂度可以达到O(m+n)

需要解决的问题是：失配时，主串中第i个字符与模式串中的哪个字符再比较？

 

T[1..k-1] == T[j-k+1..j-1]成立

 

若令next[j]=k,则next[j]表明当模式串中第j个字符与主串中第i个字符失配时，在模式串中需重新和主串中该字符进行比较的字符的位置。

 

定义：模式串的next函数

 

 

 

int Index_KMP(SString S, SString T, int pos)
{ //  1≤pos≤StrLength(S)
     i = pos;   j = 1;
     while (i <= S[0] && j <= T[0]) {
         if (j = 0 || S[i] == T[j]) 
         { ++i;  ++j; }
        // 继续比较后继字符
        else  j = next[j];         // 模式串向右移动
     }
    if (j > T[0])  return  i-T[0]; // 匹配成功
    else return 0;
} // Index_KMP