串的表示和实现

串：串是由零个或多个字符组成的有限序列，又名叫字符串。
串的顺序存储结构：用一组地址连续的存储单元来存储串中的字符序列。规定在串值后面加一个不计入串长度的结束标记字符，为’\0’。
串的表示和实现如下：

"mystring.h"

#pragma once
#define MAXSIZE 100

typedef struct  
{
    char str[MAXSIZE];
}string;

//生成一个其值等于字符串常量ch串t
void StrAssign(string *t,const char *ch);
//串s存在，由串s复制得到串t
void StrCopy(string *t,string s);
//串s存在，将串清空
void ClearString(string *s);
//若串s为空，返回true，否则返回false
bool StringEmpty(string s);
//返回串s的元素个数，即串的长度
int StrLength(string s);
//若s>t，返回值>0，若s=t，返回值=0，若s<t，返回值<0
int StrCompare(string s1,string s2);
//用t返回由s1和s2联接而成的新串
void Concat(string *t,string s1,string s2);
//串s存在，1<=pos<=StrLength(s),且0<=len<=StrLength(s)-pos+1,
//用sub返回s的第pos个字符起长度为len的子串
void SubString(string *sub,string s,int pos,int len);
//串s和t存在，t为非空串，1<=pos<=StrLength(s)
//若主串s中存在和串t值相同的子串，则返回它在主串s中第pos个字符之后第一次出现的位置，否则返回0
void Index(string s,string t,int *pos);
//串s、t和v存在，t为非空串。用v替代主串s中出现的所有与t相等的不重叠的子串
void Replace(string *s,string t,string v);
//串s和t存在，1<=pos<=StrLength(s)+1,在串s的第pos个字符之前插入串t
void StrInsert(string *s,int pos,string t);
//串s存在，1<=pos<=StrLength(s)-len+1，从串s中删除第pos个字符起长度为len的子串
void StrDelete(string *s,int pos,int len);

"mystring.cpp"

#include "mystring.h"
#include <stdio.h>
#include <assert.h>

//生成一个其值等于字符串常量ch串t
void StrAssign(string *t,const char *ch)
{
    int i = 0;
    while (*ch)
    {
        t->str[i++] = *ch;
        ch++;
    }
    t->str[i] = 0;
}

//串s存在，由串s复制得到串t
void StrCopy(string *t,string s)
{
    int i = 0;
    while (s.str[i])
    {
        t->str[i] = s.str[i];
        i++;
    }
    t->str[i] = 0;
}

//串s存在，将串清空
void ClearString(string *s)
{
    int i = 0;
    while (s->str[i])
    {
        s->str[i++] = 0;
    }
}

//若串s为空，返回true，否则返回false
bool StringEmpty(string s)
{
//  printf("%d\n",*(s.str));
    return *(s.str) == 0;
}

//返回串s的元素个数，即串的长度
int StrLength(string s)
{
    int i = 0;
    while (s.str[i++])
    ;
    return i-1;
}

//若s>t，返回值>0，若s=t，返回值=0，若s<t，返回值<0
int StrCompare(string s1,string s2)
{
    int i = 0;
    while (s1.str[i]==s2.str[i])
    {
        if (s1.str[i] == '\0' && s2.str[i] == '\0')
        {
            return 0;
        }
        i++;
    }
    return s1.str[i] - s2.str[i];
}

//用t返回由s1和s2联接而成的新串
void Concat(string *t,string s1,string s2)
{
    int i = 0;
    while (s1.str[i])
    {
        t->str[i] = s1.str[i];
        i++;
    }
    int j = 0;
    while (s2.str[j])
    {
        t->str[i++] = s2.str[j++];
    }
    t->str[i] = 0;
}
//串s存在，1<=pos<=StrLength(s),且0<=len<=StrLength(s)-pos+1,
//用sub返回s的第pos个字符起长度为len的子串
void SubString(string *sub,string s,int pos,int len)
{
    assert(pos >=1 && pos <= StrLength(s));
    assert(len >= 0 && len <= StrLength(s) - pos+1);
    int i;
    int p = pos-1;
    for (i=0;i<len;++i)
    {
        sub->str[i] = s.str[p++];
    }
    sub->str[i] = 0;
}

//串s和t存在，t为非空串，1<=pos<=StrLength(s)
//若主串s中存在和串t值相同的子串，则返回它在主串s中第pos个字符之后第一次出现的位置，否则返回0
void Index(string s,string t,int *pos)
{
    *pos = 0;
    char *p,*q;
    p = s.str;
    q = t.str;
    int i,j;
    int len1,len2;
    i = j = 0;
    len1 = StrLength(s);
    len2 = StrLength(t);
    while (i < len1)
    {
        while(p[i] == q[j])
        {
            i++;
            j++;
            if (j == len2)
            {
                *pos = i - len2;
                return;
            }
        }
        if (j = 0)
        {
            i++;
        }
        else
        {
            j = 0;
            i = i - j + 1;
        }
    }
}

//串s、t和v存在，t为非空串。用v替代主串s中出现的所有与t相等的不重叠的子串
void Replace(string *s,string t,string v)
{
    char *p = s->str;
    int i;
    int len1;
    int len2 = StrLength(t);//被替换的子串
    int len3 = StrLength(v);//新的子串
    int pos;
    Index2(*s,t,&pos);//被替换的子串第一次出现的位置
    while(pos)//当位置不为0时
    {   
        if (len3>len2)//如果新的子串长度大于被替换的子串的长度
        {
            len1 = StrLength(*s);
            //将原串后移
            for (i=len1;i>=pos;--i)
            {
                p[i+len3-len2] = p[i];
            }
            //将新串插入
            for (i=pos;i<pos+len3;++i)
            {
                p[i] = v.str[i-pos];
            }

        }
        else if(len3<len2)
        {
            len1 = StrLength(*s);
            //原串向前移动
            for (i=pos+len3;i<len1;++i)
            {
                p[i] = p[i+len2-len3];
            }
            //将新串复制
            for(i=0;i<len3;i++)
            {
                p[pos+i] = v.str[i];
            }
        }
        else
        {
            for (i=0;i<len3;++i)
            {
                p[pos+i] = v.str[i];
            }
        }
        Index2(*s,t,&pos);
    }
}
//串s和t存在，1<=pos<=StrLength(s)+1,在串s的第pos个字符之前插入串t
void StrInsert(string *s,int pos,string t)
{
    char *p = s->str;
    int len1 = StrLength(*s);
    int len2 = StrLength(t);
    assert(pos >= 0 && pos <= StrLength(*s));
    int i;
    //从len1位置开始向后移动子串t的长度,直到pos位置
    for (i=len1;i >= pos;--i)
    {
        p[i+len2] = p[i];
    }
    //从位置pos开始插入子串t
    for (i=pos;i<pos+len2;++i)
    {
        p[i] = t.str[i-pos];
    }
}
//串s存在，1<=pos<=StrLength(s)-len+1，从串s中删除第pos个字符起长度为len的子串
void StrDelete(string *s,int pos,int len)
{
    assert(pos >= 0 && pos <= StrLength(*s)-len);
    char *p = s->str;
    int j;

    //每次向前移动len个长度
    for (j=pos;j<StrLength(*s);++j)
    {
        p[j] = p[j+len];
    }
}