串的基本操作

#include <iostream>
#include <algorithm>
#include <cstring>
#define sqtrmax 1000
using namespace std;
typedef struct
{
    char *data;
    int length;
} sqtr;
void StrAssign (sqtr &S, char *chars);               //赋值
void Destroy(sqtr &S);                         //销毁
void StrCopy (sqtr &T,sqtr S);                  //复制
int StrLength(sqtr S);                            //长度
int StrEmpty (sqtr S);                               //判空
void Concat (sqtr &T,sqtr S1,sqtr S2);             //串联接
int StrCompare (sqtr S, sqtr T);                  //比较
int SubString (sqtr &Sub,sqtr S,int pos,int len);   //求子串
void ClearString (sqtr &S);                        //清空
int Index (sqtr S,sqtr T,int pos);                //定位函数
void Replace (sqtr &S, sqtr T,sqtr V);                  //串置换
int StrInsert (sqtr &S,int pos, sqtr T);              //插入
int StrDele (sqtr &S,int pos,int len);               //删除
void StrOutput(sqtr S) ;                              //输出
int main()
{
    char str[12]="abcssasdsss",str1[4]="sss",str2[4]="vvv";
    sqtr S,T,V,S1,Sub;
    S.data=NULL;
    T.data=NULL,V.data=NULL;
    StrAssign(S,str);
    StrAssign(T,str1);
    StrAssign(V,str2);
    cout<<"串S：";
    StrOutput(S);
    cout<<endl;
    cout<<"串T：";
    StrOutput(T);
    cout<<endl;
    cout<<"串V：";
    StrOutput(V);
    cout<<endl;
    cout<<"求第3个后S中与T相等的子串的位置";
    cout<<Index(S,T,3);
    cout<<endl;
    cout<<"求第3个后S中长度为3的子串";
    SubString(Sub,S,3,3);
    StrOutput(Sub);
    cout<<endl;
    cout<<"在串S的第10个字符之前插入串T：";
    StrInsert(S,10,T);
    StrOutput(S);
    cout<<endl;
    cout<<"删除串S从第2个字符起长度为3的子串：";
    StrDele(S,2,3);
    StrOutput(S);
    cout<<endl;
    cout<<"连接T,V到S1";
    Concat(S1,T,V);
    StrOutput(S1);
    cout<<endl;
    //cout<<"\n"<<"采用KMP算法进行模式匹配：";
    //cout<<Index_KMP(S,T,1)<<endl;
    cout<<"用串V替换S中与T相等的所有子串：";
    Replace(S,T,V);
    StrOutput(S);
    cout<<endl;






}
/**赋值**//*strcpy(S.data,chars);*/
void StrAssign (sqtr &S, char *chars)
{
    int i;
    S.data=(char *)malloc(sqtrmax *sizeof(char));
    if(!S.data) exit(0);
    for(i=0; chars[i]!='\0'; i++)
        S.data[i]=chars[i];
        S.data[i]='\0';
    S.length=i;
}
/**长度**//*strlen(S.data);*/
int StrLength(sqtr S)
{
    return S.length;
}
/**判空**/
int StrEmpty (sqtr S)
{
    if(!S.length)  //长度=0
        return 1;
    else
        return 0;
}
/**复制**//*strcpy(S.data,chars);*/
void StrCopy (sqtr &T,sqtr S)
{
    StrAssign(T,S.data);//不是S
}




/**清空**/
void ClearString (sqtr &S)
{
    if(S.data)
    {
        delete S.data;
        S.data=NULL;
    }
    S.length=0;
}
/**销毁 似清空**/
void Destroy(sqtr &S)
{
    if(S.data)
    {
        delete S.data;
        S.data=NULL;
    }
}
/**比较**//*(strcmp(S.data,T.data)==0)*/
int StrCompare (sqtr S, sqtr T)
{
    int i;
    for(i=0; i<S.length&&i<T.length; i++)
        if(S.data[i]!=T.data[i])
            return S.data[i]-T.data[i];//S的值大就>0
    return S.length-T.length;
    //注意return有终止作用，谁先执行就return谁；
}
/**删除**/
int StrDele (sqtr &S,int pos,int len)
{
    if(pos<1||pos>S.length-len+1)
        return 0;
    int i=0;
    while(i<pos-1)
        i++;
    for(i=pos-1; i<S.length-len; i++)
        S.data[i]=S.data[i+len];
    S.data[i]='\0';
    S.length-=len;


}
/**串联接**/
void Concat (sqtr &T,sqtr S1,sqtr S2)
{
    T.length=S1.length+S2.length+1;
    T.data=(char *)malloc(S1.length+S2.length *sizeof(char));
    int j=0,k=0;
    while(S1.data[j]!='\0') T.data[k++]=S1.data[j++];
    j=0;
    while(S2.data[j]!='\0') T.data[k++]=S2.data[j++];
    T.data[k]='\0';
}
/**求子串**/
int SubString (sqtr &Sub,sqtr S,int pos,int len)
{
    // 以 Sub 返回串 S 中第 pos 个字符起长度为 len 的子串
    Sub.data=(char *)malloc(len *sizeof(char));
    Sub.length=len;
    int i,k;
    if(pos<1)
        return 0;
    i=0;
    while(i<pos-1&&S.data[i]!='\0') i++;
    if(i<pos-1||S.data[i]=='\0')
        return 0;
    else
    {
        k=0;
        while(len--&&S.data[i]!='\0')
        {
            Sub.data[k++]=S.data[i++];
            //cout<<Sub.data[k-1]<<endl;
        }
        if(k<S.length) return 0;
        else
            Sub.data[k]='\0';


    }
}
/**定位函数**/
int Index (sqtr S,sqtr T,int pos)
{
    //若主串 S 中存在和串 T 值相同的子串，则返回它在主串 S 中第 pos个字符之后第一次出现的位置; 否则函数值为0。
    int i,j;
    if(pos>0)
    {
        i=pos-1;
        j=0;
        while(S.data[i+j]!='\0'&&T.data[j]!='\0')
        {
            if(S.data[i+j]==T.data[j])
            {
                j++;
            }
            else
            {
                i++;//相当于二重for循环中跳出j，进入i循环
                j=0;
            }
        }
        if(T.data[j]=='\0')
                return i+1;
            else
            return 0;
    }
}
/**串置换**///用 V 替换主串 S 中出现的所有与模式串）T 相等的不重叠的子串。
void Replace (sqtr &S,sqtr T,sqtr V)
{
    sqtr news,sub;
    news.data=(char *)malloc(sqtrmax *sizeof(char));
    news.data=NULL;
    int n=S.length,m=T.length;
    int i=1,pos=1,j=0;
    while(pos<=n-m+1&&i)//n-m+1
    {
        i=Index(S,T,pos);
        if(i!=0)//不能写i，因为i是位置，不一定啥数
        {
            SubString(sub,S,pos,i-pos);
            if(j==0)
            {
            Concat(news,sub,V);
            }
            else
            {
                if(i-pos!=0)
                Concat(news,news,sub);
                Concat(news,news,V);//当非第一次时，后面要直接连在news上
            }
            pos=i+m;
            j++;
        }


    }
    SubString(sub,S,pos,n-pos+1);
    if(n-pos+1!=0)
    Concat(S,news,sub);
    StrAssign(S,news.data);
}
/**插入**/
int StrInsert (sqtr &S,int pos,sqtr T)
{
    int sl=S.length,tl=T.length;// 在串 S 的第 pos(1≤pos≤StrLength(S)＋1) 个字符之前插入串T
    char S1[sl+1] ;            // 设S1为辅助串空间
    if (pos < 1 || pos > sl+1)
        return 0;               // 插入位置不合法;
    if (tl>0)
    {
        int i=0,k,j;
        while ( S.data[i]!='\0')
        {
            S1[i]=S.data[i];
            i++;// 暂存串S
        }
        S1[i]='\0';
        S.data= (char *)malloc((sl + tl +1) *sizeof(char));   // 重新分配空间
        for ( i=0, k=0; i<pos-1; i++)
        {
            S.data[k++] = S1[i];
            // 保留插入位置之前的子串
        }
        j = 0;
        while ( T.data[j]!= '\0')
        {
            S.data[k++] = T.data[j++];
        }     // 插入T
        while ( S1[i] != '\0')
            S.data[k++] = S1[i++];  // 复制插入位置之后的子串
        S.data[k] = '\0';
        S.length=k;                      // 置串S的结束标志
    }
}
/**输出**/
void StrOutput(sqtr S)
{
    int i=0;
    while(i<S.length)
    {
        cout<<S.data[i];
        i++;
    }
}V