王道数据结构—串的存储结构及基本操作

串

存储结构和基本操作

1、定长存储

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXLEN 255
typedef struct{
    char ch[MAXLEN];   //存储每一个字符，第0位舍弃
    int length;
}SString;

//赋值，把串str复制到串s
bool StrAssign(SString  &s, char * str)  //赋值
{
    int i;
    int len=strlen(str);
    if(len>MAXLEN)
        return false;
    for(i=1;i<=len;i++){
        if(str[i-1]!='\n')
            s.ch[i]=str[i-1];
    }
    s.length=len;
    return true;
}

//复制操作
bool StrCopy(SString &S,SString T){
    int len=T.length;
    int i=1;
    if(len>MAXLEN)
        return false;
    for(i=1;i<=len;i++){
        S.ch[i]=T.ch[i];
    }
    S.length=T.length;
    return true;
}

//判空操作
bool StrEmpty(SString S){
    if(S.length==0)
        return true;
    else
        return false;
}

//串连接
bool Concat(SString &T,SString S1,SString S2){
    int i=1;
    if(S1.length+S2.length>MAXLEN)
        return false;
    for(i=1;i<=S1.length;i++){
        T.ch[i]=S1.ch[i];
    }
    for(i=S1.length+1;i<=S1.length+S2.length;i++){
        T.ch[i]=S2.ch[i-S1.length];
    }
    T.length=S1.length+S2.length;
    return true;
}

//求子串.用Sub返回自第pos个 字符起长度为len的字符串
bool SubString(SString &Sub,SString S,int pos,int len){
    //子串范围越界
    if(pos+len-1>S.length)
        return false;
    for(int i=pos;i<pos+len;i++)
        Sub.ch[i-pos+1]=S.ch[i];
    Sub.length=len;
    return true;
}

//比较操作。若S>T，返回值>0；若S=T，返回值为0;若S<T,返回值<0
int StrCompare(SString S,SString T){
    for(int i=1;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;
}

//定位操作。若主串S中存在与串T值相同的子串，则返回它在主
//串S中第一次出现的位置，否则返回0
int Index(SString S,SString T){
    int i=1,n=S.length,m=T.length;
    SString sub;
    while(i<=n-m+1){
        SubString(sub,S,i,m);
        if(StrCompare(sub,T)!=0) ++i;
        else return i;
    }
    return 0;
}


//打印串
void PrintString(SString S){
    int i=1;
    for(i=1;i<=S.length;i++){
        printf("%c ",S.ch[i]);
    }
    printf("字符串长度为%d",S.length);
    printf("\n");
}

int main(){
    SString S1,S2,S,sub;
    int index;
    char ch[10]="abcdefghi";
    char ch2[5]="defg";
    StrAssign(S1,ch);
    StrAssign(S2,ch2);
    printf("初始化后的字符串S1为：\n");
    PrintString(S1);
    printf("初始化后的字符串S2为：\n");
    PrintString(S2);
    Concat(S,S1,S2);
    printf("S1、S2连接后的字符串S为：\n");
    PrintString(S);
    SubString(sub,S,6,6);
    PrintString(sub);
    index=Index(S,S2);
    printf("S2在S的起始位置为：%d\n",index);
    return 0;
}

2、堆分配存储

typedef struct{
   char *ch;     //按串长分配存储空间，ch指向串的基地址
   int length;   //串的长度
}HString;

3、块链存储

typedef struct StringNode{
    char char[4];
    struct StringNode *next;
}StringNode,*String;

模式匹配

1、朴素模式匹配

//即定位操作index，这里不嵌套基本操作来实现
//i-j+2：j说明了当前匹配到了子串的第几个字符，i-j会指向当前子串的前一个字符，+2会指向下一个子串的第一个字符
int Index(SString S,SString T){
    int i=1,j=1;
    while(i<=S.length&&j<=T.length){
        if(S.ch[i]==T.ch[j]){
            ++i,++j;
        }
        else{
            i=i-j+2;
            j=1;
        }
    }
    if(j>T.length)
        return i-T.length
    else
        return 0;
}
            

2、改进模式匹配—KMP算法

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXLEN 255
typedef struct{
    char ch[MAXLEN];   //存储每一个字符，第0位舍弃
    int length;
}SString;

//赋值，把串str复制到串s
bool StrAssign(SString  &s, char * str)  //赋值
{
    int i;
    int len=strlen(str);
    if(len>MAXLEN)
        return false;
    for(i=1;i<=len;i++){
        if(str[i-1]!='\n')
            s.ch[i]=str[i-1];
    }
    s.length=len;
    return true;
}

int get_next(SString T,int next[]){
   int i=1,j=0;
   next[1]=0;
   while(i<T.length){
      if(j==0||T.ch[i]==T.ch[j]){
          ++i;++j;
          next[i]=j;     //若pi=pj，则next[j+1]=next[j]+1
      }
      else
          j=next[j];    //否则令j=next[j]，循环继续
   }
   return 0;
}

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


//打印串
void PrintString(SString S){
    int i=1;
    for(i=1;i<=S.length;i++){
        printf("%c ",S.ch[i]);
    }
    printf("字符串长度为%d",S.length);
    printf("\n");
}

int main(){
    SString S,T;
    int *next;
    char ch[10]="abcdefghi";
    char ch2[5]="defg";
    StrAssign(S,ch);
    StrAssign(T,ch2);
    next=(int*)malloc(sizeof(int)*(T.length+1));
    get_next(T,next);
    next[0]=-1;
    for(int i=0;i<=T.length;i++){
        printf("%d ",next[i]);
    }
    printf("\n");
    if(Index_KMP(S,T,next))
        printf("匹配成功！第一个字符位置为：%d",Index_KMP(S,T,next));
   else
        printf("匹配失败！");
    printf("\n");
    return 0;

}

*3、KMP算法的进一步优化