数据结构 - 串的性质和基本操作（二）

串的顺序存储结构

①定长顺序存储

结构类型：

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

分析：

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

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

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

（第一种情况）

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;
     }
     return uncut;
} 

注意： 用T返回由S1和S2联接而成的新串。若未截断, 则返回TRUE，否则FALSE。

（第二种情况）

Status Concat(SString S1, SString S2, SString &T) {
  if (S1[0]+S2[0] <= MAXSTRLEN) {// 未截断

  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;
     }
     return uncut;
} 

注意： 用T返回由S1和S2联接而成的新串。若未截断, 则返回TRUE，否则FALSE。

（第三种情况）

Status Concat(SString S1, SString S2, SString &T) {
  if (S1[0]+S2[0] <= MAXSTRLEN) {// 未截断

  else if (S1[0] <MAXSTRSIZE) { // 截断
    else{
    T[0..MAXSTRLEN] = S1[0..MAXSTRLEN];
    // T[0] == S1[0] == MAXSTRLEN
    uncut = FALSE;           }

    return uncut;
} 

注意： 用T返回由S1和S2联接而成的新串。若未截断, 则返回TRUE，否则FALSE。

②堆分配存储

分析：

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

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

（3）C语言中的串以一个空字符(‘\0’)为结束符， 串长是一个隐含值

结构类型：

//按串长分配存储区
typedef struct{
    char   *ch;
    int    length;
}HString;

注意：

（1）在程序执行过程中，利用标准函数malloc和free动态分配或释放存储字符串的存储单元，并以一个特殊的字符（’\0’）作为字符串的结束标志

算法实现的步骤：

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

算法如下：

int  StringAssign(HString &T, char * chars) {
    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[0..i-1] = chars[0..i-1]; //对应字符赋值
            T.length = i;
        }
    return OK;
 }

串的堆分配存储的操作实现

int StringConcat(HString &T,HString S1,HString S2){
    //T返回S1和S2联接的新串
    if(T.ch)
          free(T.ch); //释放T原来占据的空间

    if(!(T.ch=(char*)malloc((S1.length+S2.length)*sizeof(char))))

          exit (OVERFLOW);  //重新为T分配空间
          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;
}

串的链式存储结构

分析：

（1）串作为一种特殊的线性表（数据元素为字符），使用顺序表示时，做插入和删除运算，运算量很大，不方便，效率低

（2）所有经常采用链式存储结构

什么是链式存储结构呢？

如下图所示：

直接采用上面这种链表存储串值，进行操作时效率太低

这种链表存储就比上面的那种效率高