[数据结构]串

第四章 串

学习提要：

  1.熟悉串的基本操作的定义，并能利用这些基本操作来实现串的其它各种操作的方法。

  2.熟练掌握在串的定长顺序存储结构上实现串的各种操作的方法。

  3.掌握串的堆分配存储结构以及在其上实现串操作的基本方法。

  4.了解串的块链存储结构。

重难点内容：

  串的存储结构

 

4.1 串类型的定义

基本概念

串（string）：由零个或多个字符组成的有限序列，也称字符串。记为：

S =  ‘a1a2a3……an’ (n≥0)

如：A= ‘BEIJING’， B= ‘JING’

串的长度：串中字符的数目n 。

空串：不含任何字符的串，串长度为0，用“  ”或 ‘’表示。

空格串：仅由一个或多个空格组成的串， 长度为串中空格字符的个数。

    如： ‘     ’ ，   C= ‘ BEI  JING ’

子串：由串中任意个连续的字符组成的子序列。

主串：包含子串的串。

  如：A= ‘ BEIJING ’    B= ‘ JING ’

字符在串中的位置：字符在序列中的序号。

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

如：A= ‘ BEIJING ’，B= ‘JING ’，

            B在A中的位置为4。

串相等：当且仅当两个串的值相等。也就是说，只有两个串的长度相等且各个对应位置的字符都相等时才相等。

串的抽象数据类型定义

        ADT String {

         数据对象：

            D＝{ ai |ai∈CharacterSet,

                      i=1,2,...,n, n≥0 }

         数据关系：

            R1＝{ < ai-1, ai > | ai-1, ai ∈D,

                        i=2,...,n }

         基本操作：

                 

      } ADT String     

StrAssign (&T, chars) //串赋值

       初始条件：chars是字符串常量。

       操作结果：把 chars 赋为 T 的值。

StrCopy (&T, S)  //串复制

        初始条件：串S存在。

        操作结果：由串S复制得串T。

DestroyString (&S)

        初始条件：串S存在。

        操作结果：串S被销毁。

ClearString (&S)

        初始条件：串S存在。

        操作结果：将S清为空串。

StrEmpty (S)

        初始条件：串S存在。

        操作结果：若S为空串，则返回TRUE，否则返回FALSE。

StrCompare (S, T)   //串比较

        初始条件：串S和T存在。

        操作结果：若S>T，则返回值>0；

                  若S=T，则返回值=0；

                  若S<T，则返回值<0。

StrCompare(‘data’, ‘structure’) < 0

 

StrLength (S)  //求串长

        初始条件：串S存在。

        操作结果：返回S的元素个数，称为串的长度。

Concat (&T, S1, S2)   //串联接

        初始条件：串S1和S2存在。

        操作结果：用T返回由S1和S2联接而成的新串。

Concat(&T,‘data’, ‘structure’)

T=‘datastructure’

 

SubString (&Sub, S, pos, len)  //求子串

        初始条件：串S存在，1≤pos≤StrLength(S)且0≤len≤StrLength(S)-pos+1。

        操作结果：用Sub返回串S的第pos个字符起长度为len的子串。

SubString(&sub, ‘data structure’,  6, 9)

Sub=‘structure’

 

Index (S, T, pos)   //串定位

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

                       1≤pos≤StrLength(S)。

        操作结果：若主串S中存在和串T值相同的子串, 则返回它在主串S中第pos个字

                  符之后第一次出现的位置; 否则函数值为0。

假设： S = ¢abcaabcaaabc¢,  T = ¢bca¢

Index(S, T, 1) = 2；

Index(S, T, 3) = 6；

Index(S, T, 8) = 0；

 

Replace (&S, T, V)  //串替换

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

       操作结果：用V替换主串S中出现的所有与T相等的不重叠的子串。

例如：S=‘abcaabc’, T=‘ab’, V=‘x’

      S=‘xcaxc’

      V=‘bc’

      S=‘bccabcc’

 

StrInsert (&S, pos, T)

      初始条件：串S和T存在，1≤pos≤StrLength(S)＋1。

      操作结果：在串S的第pos个字符之前插入串T。

例如：S＝‘god’， StrInsert ( ＆S, 2, ‘o’)

      S=‘good’

 

StrDelete (&S, pos, len)

      初始条件：串S存在，1≤pos≤StrLength(S)-len+1。

      操作结果：从串S中删除第pos个字符起长度为len的子串。

例如：S= ‘structure’，

           StrDelete( ＆S, 1, 5)

           S=‘ture’

 

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

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

  gets(str)  输入一个串；

  puts(str) 输出一个串；

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

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

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

  strlen(str)  求串长函数；

在以上操作中，串赋值StrAssign、串复制Strcopy、串比较StrCompare、求串长StrLength、串联接Concat、求子串SubString 6种操作构成串类型的最小操作子集，

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

    

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

算法的基本思想为：

StrCompare(SubString(S, i, StrLength(T)), T) = = 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

 

 

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

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

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

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

 

4.2  串的表示和实现

4.2.1 定长顺序存储表示

   用一组地址连续的存储单元存储串值的字符序列，类似于线性表的顺序存储结构。所谓定长顺序存储结构，是直接使用定长的字符数组来定义，数组的上界预先给出：

 #define MAXSTRLEN 255

                           // 用户可在255以内定义最大串长

 typedef unsigned char

               SString[MAXSTRLEN + 1];

                                       // 0号单元存放串的长度

特点:

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

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

 

1．串联结Contcat（&T,S1,S2）

 

S1[0]+S2[0] <= MAXSTRLEN

 

S1[0] < MAXSTRSIZE 而S1[0]+S2[0] > MAXSTRSIZE

 

S1[0] = MAXSTRLEN

 

Status Concat(SString S1, SString S2, SString &T) {

    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[0] = MAXSTRSIZE截断(仅取S1)

                  T[0...MAXSTRLEN] = S1[0…MAXSTRLEN];

                                            // T[0] == S1[0] == MAXSTRLEN

                uncut = FALSE;  }

   return uncut;

 } // Concat

2．求子串SubString(&Sub, S, pos, len)

Status SubString(SString&Sub, SString S, int pos,int len) {

// 用Sub返回串S的第pos个字符起长度为len的子串。其中       1≤pos ≤StrLength(S) 且 0≤len≤StrLength(S)-pos+1

   if (pos<1 ||pos>S[0] || len<0 || len>S[0]-pos+1)

         return ERROR;

   Sub[1……len]=S[pos…pos+len-1]；

   Sub[0]=len；

   return OK;

} // SubString

4.2.2 堆分配存储表示

    以一组地址连续的存储单元存储串值的字符序列，存储空间在程序执行过程中动态分配。     

    C语言中提供的串类型就是以这种存储方式实现的。系统利用函数malloc()和free( )进行串值空间的动态管理，为每一个新产生的串分配一个存储区，称串值共享的存储空间为“堆”。

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

typedef struct {

     char *ch;    // 若是非空串，则按串长分

                            配存储区,否则ch为NULL

      int length;  // 串长度

} HString;

这类串操作实现的算法为：

    先为新生成的串分配一个存储空间，然后进行串值的复制。

1. 串赋值

Status StrAssign(Hstring&T,char*chars){

// 生成一个其值等于串常量chars的串T

  If   ( T.ch )  free (T.ch);  //释放T原有空间

  for(i=0,c=chars; c; ++i,++c);   //求chars的长度 i

  If ( !i ) {T.ch=NULL; T.length=0;}

  else{

       if(!(T.ch=(char*)malloc(i*sizeof(char))))

            exit(OVERFLOW);

       T.ch[0…i-1]=chars[0…i-1];     T.length=i;  }

  return OK;

}// StrAssign

2.串比较

Int StrCompare(Hstring S,Hstring T){

  //若S>T，则返回值>0; 若S=T，则返回值=0；若S<T，则返回值=0

  for(i=0; i<S.length && i<T.length; ++i)

      if (S.ch[i]!=T.ch[i])    return S.ch[i]-T.ch[i];

 Return  S.length - T.length;

}// StrCompare

3. 串联接

Status Concat(Hstring&T,HStringS1,HstringS2){

  //用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

4. 取子串

Status SubString(HString&Sub,Hstring S,int pos,int len) {// 用Sub返回串S的第pos个字符起长度为len的子串。

  // 其中1≤pos StrLength(S) 且 0≤ len≤ StrLength(S)-pos+1

  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.ch[pos-1…pos+len-2]；    

     Sub.length=len；

  return OK;

} // SubString

 

4.2.3 块链存储表示

    以链表存储串值，除头指针外还可以附设一个尾指针指示链表中的最后一个结点，并给出当前串的长度。称如此定义的传存储结构为块链结构。

 

 #define  CHUNKSIZE  80  // 可由用户定义的块大小

 typedef  struct Chunk {  // 结点结构

    char  ch[CUNKSIZE];

    struct Chunk  *next;

  } Chunk;

 typedef struct {  // 串的链表结构

    Chunk *head, *tail; // 串的头和尾指针

     int   curlen;     // 串的当前长度

  } LString;

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