数据结构第四章 串 的基本操作集

---

1.顺序串的基本定义

typedef struct{
    char data[MaxSize];
    int length;   //存放串长
}SqString;

2.生成串 StrAssign(&s,cstr) 将一个 字符串常量cstr（以’\0’字符标识结尾)赋给顺序串 s)

void StrAssign(SqString &s, char cstr[]){
    int i;
    for(i=0;cstr[i]!='\0';i++)
    s.data[i]=cstr[i];
    s.length=i;
}

3.串的复制

void StrCpy(SqString &s, SqString t) {
    //注意S为引用型参数
    int i;
    for(i = 0; t[i] != '\0'; i++)
        s.data[i] = t.data[i];
    s.length = i;
}

4.判断串相等 StrEqual(s,t)

bool StrEqual(SqString s, SqString t) {
    bool same = true;
    int i;
    if(s.length != t.length)  //长度不相同时返回0
        same = false;
    else
        for(i = 0; i < s.length; i++)
            if(s.data[i] != t.data[i]) {
            //只要有一个不相等时返回假
            same = false;
            break;
        }
    return same;
}

5.串的连接(返回由两个顺序串s和t连接在一起形成的结果串)

SqString Concat(SqString s, SqString t) {
    SqString str; //定义结果串
    int i;
    str.length = s.length+t.length; //首先设置结果串的长度为两串长度之和
    for(i = 0; i < s.length; i++)
        str.data[i] = s.data[i];    //将s.data[0.1.2...s.len-1]复制到 str
    for(i = 0; i < t.length; i++)
        str.data[s.length+i] = t.data[i];   //将 t.data[0.1.2...t.length-1]复制到str
    return str;   //返回结果串
}

6.求子串 SubStr(s,i,j)(返回顺序串s中从第i(1<=i<=n)个字符开始的由连续j个字符组成的子串。当参数不正确时返回一个空串)

SqString SubStr(SqString s,int i,int j){
    int k;
    SqString str;  //定义结果串
    str.length=0;  //设置str为空串
    if(i<=0||i>s.length||j<0||i+j-1>s.length)
        return str;   //参数不正确时候返回空串
    for(k=i-1;k<i+j-1;k++)
        str.data[k-i+1]=s.data[k];  //将s.data[i.i+1.i+2.i+3...i+j-1]复制到str
    str.length=j;    //不要忘记设置结果串 str 的长度
    return str; 
}

7.子串的插入InsStr(S1,i,S2)(将顺序串S2插入到顺序串S1的第i(1<=i<=n+1)个位置上,并返回产生的结果串。当参数不正确时返回一个空串)

SqString InsStr(SqString s1,int i,SqString s2){
    int j;
    SqString str;  //定义结果串
    str.length=0; //设置str为空串
    if(i<=0||i>s1.length+1)
        return str;  //参数正确时返回一个空串
    for(j = 0;j < i-1;j++)
      str.data[j]=s1.data[j];   //首先将 s1.data[0.1.2...i-2]复制到str中
    for(j = 0;j < s2.length; j++)
      str.data[i+j-1]=s2.data[j];   //再将要插入的s2.data[0.1.2...s2.length-1]复制到str中,这里要注意下标问题,str的下标为 i+j-1
    for(j = i-1; j<s1.length; j++)
      str.data[s2.length+j]=s1.data[j];  //最后将s1.data[i-1.i.i+1...s1.length-1]复制到str中
    str.length=s1.length+s2.length;   //不要忘记设置结果串的长度,本人经常忘记
      return str;
}

8.子串的删除 DelStr(s,i,j)(在顺序串s中删除从第i(1<=i<=n)个字符开始的长度为j的子串，并返回产生的结果.当参数不正确时返回一个空串)

SqString DelStr(SqString s,int i,int j){
    int k;
    SqString str;  //定义结果串
    str.length=0;  //设置str为空串
    if(i<=0||i>s.length||i+j-1>s.length)
      return str;  //参数不正确时候返回空串
    for(k = 0;k<i-1;k++)
        str.data[k]=s.data[k];   //首先将s.data[0.1.2.3....i-2]复制到str中
    for(k=i+j-1;k<s.length;k++)
        str.data[k-j]=s.data[k];   //再将s.data[i+j-1.i+j.i+j+1...s.length-1]复制到str中,要注意下标问题。
    str.length=s.length-j;
    return str;
}

9.子串的替换 RepStr(SqString s,int i,int j,SqString t)
//(在顺序串s中将第i(1<=i<=n)个字符开始的长度为j的子串用顺序串t替换，并返回产生的结果.当参数不正确时返回一个空串)

SqString RepStr(SqString s,int i,int j,SqString t){
    int k;
    SqString str; //定义结果串
    str.length=0;  //设置str为空串
    if(i<0||i>s.length||i+j-1>s.length)
        return str;  //参数不正确的时候返回一个空串
    for(k = 0;k < i-1;k++)
        str.data[k]=s.data[k];  //首先将s.data[0.1.2.3...i-2]复制到str中
    for(k = 0;k < t.length; k++) 
        str.data[i+k-1]=t.data[k];  //再将t.data[0.1.2...t.length-1]复制到str中
    for(k=i+j-1;k<s.length;k++)
        str.data[t.length+k-j]=s.data[k];     //再将s.data[i+j-1,i+j,i+j+1...s.length-1]复制到str中,要注意下标问题。
    str.length=s.length-j+t.length;   //最后设置结果串s的长度
    return str;
}

10.输出串 DispStr(s)

void DispStr(SqString s){
    int i;
    if(s.length>0){
        for(i = 0; s[i]!='\0';i++)
            printf("%c",s[i]);
            printf("\n");
    }
}

例子：假设采用顺序串存储,设计一个算法 Strcmp(s,t) 按字典顺序比较两个串s和t的大小。
(1)比较s和t两个串共同长度范围内的对应字符：
1. 若s的字符大于t的字符，返回1；
2. 若s的字符小于t的字符，返回-1；
3 若s的字符等于t的字符，按照上述规则继续比较。
(2)当(1)中的对应字符均相同时比较s和t的长度:
1.两者相等返回0
2.s的长度大于t的长度，返回1；
3.若s的长度小于t的长度，返回-1；
对应的算法如下:**

int Strcmp(SqString s,SqString t){
    int i,comlen;
    if(s.length<t.length)  //求s和t的共同长度
        comlen=s.length;
    else 
        comlen=t.length;
    for(i = 0;i < comlen;i++){
        if(s.data[i]>t.data[i])
            return 1;
        else if(s.data[i]<t.data[i])
            return -1;
    }
        if(s.length==t.length)   //s==t
            return 0;
        else if(s.length>t.length) //s>t
            return 1;
        else 
            return -1;  //s<t
}

例子：假设采用顺序串存储，设计一个算法求串s中出现的第一个最长的连续相同字符构成的平台；

void LongestString(SqString s,int &index,int &maxlen){
    int length,i=1,start;
    index=0,maxlen=1;
    while(i<s.length)
    {
        start=i-1;  //查找局部所求重复子串
        length=1;  //length保留每一个的所求平台长度
        while(i<s.length&&s.data[i]==s.data[i-1])
        {
            i++;
            length++;
        }
        if(maxlen<length){  //当前平台长度大，则更新 maxlen
            maxlen = length;
            index  = start;
        }
        i++;
    }
}

BF 算法： (https://mooc1-1.chaoxing.com/mycourse/studentstudy?chapterId=140742219&courseId=202979395&clazzid=6257225&enc=f829c76fbc740f779e1b92cb89811ffa)

KMP算法 : (https://mooc1-1.chaoxing.com/mycourse/studentstudy?chapterId=140742219&courseId=202979395&clazzid=6257225&enc=f829c76fbc740f779e1b92cb89811ffa)

这篇只是个人学习过程记录，希望有所帮助！