*串的基本操作*

#include <stdlib.h>
#include <stdio.h>
#include <string.h>


//静态：
void conat(char t[], char s1[], char s2[])//字符串连接, t串为由 s2 串联接到 s1 串构成的新串
{
    int j=0, k=0;
    while(s1[j]!='\0')
        t[k++]=s1[j++];
    j=0;
    while(s2[j]!='\0')
        t[k++]=s2[j++];
    t[k]='\0';
}

bool substring(char sub[], char s[], int pos, int len)//求子串
{
    if(pos<1) return -1;
    int i;
    while(i<pos-1&&s[i]!='\0')//将i定位到子串的开始位置
        i++;
    if(i<pos-1||s[i]=='\0')//pos的位置不合法
        return -1;
    else
    {
        int k=0;
        while(k<len&&s[i]!='\0')
            sub[k++] = s[i++];
        if(k<len)//循环中止，即未达到子串要求的长度（length(s)-pos+1<len）
            return -1;
        else
        {
            sub[k]='\0';
            return 1;
        }
    }
}


int index(char s[], char t[], int pos)// T为非空串。若主串S中第 pos 个字符之后存在与t相等的子串，
// 则返回第一个这样的子串在S中的 位置，否则返回0
{
    if(pos>0)
    {
        int i=pos-1;
        int j=0;
        while(s[i+j]!='\0'&&t[j]!='\0')
        {
            if(s[i+j]==t[j])
                j++;        //继续比较后继字符
            else
            {
                i++;
                j=0;
            }//i后移，重新开始新一轮比较
        }
        if(t[j]=='\0') //匹配成功
            return (i+1);
        else           //不存在和串t相同的子串
            return -1;
    }
    return -1; // 位置不合法，s中不存在与t相等的子串

}

//动态

typedef int status;
typedef struct
{
    char *ch; //若是非空串，按串长分配存储区， 否则ch为NULL
    int   length; //串长度
}String;

status initstring(String &s)//初始化一个串
{
     s.ch = (char *)malloc(sizeof(char));
     if(!s.ch) exit(0);
     s.ch=NULL;
     s.length = 0;
     return 1;
}

status strassign(String &t, char *str)//为串t赋值
{
    if(t.ch)
        free(t.ch); //释放t原有空间
    int i=0;
    while(str[i]!='\0') //求str长度i
        i++;
    if(!i)
    {
        t.ch = NULL;
        t.length = 0;
    }
    else
    {
        t.ch = (char *) malloc ((i+1) * sizeof(char));
        if(!t.ch) exit(0);
        int j=0;
        for(j=0; j<i; j++)
            t.ch[j]=str[j];
        t.length = i;
    }
    return 1;
}

int strlength(String &s)
{
    return s.length;
}

status strcompare(String s, String t)
{
    int i=0;
    for(i=0; 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;//相等的情况
}

status clearstring(String &s)
{
    if(s.ch)
    {
        free(s.ch);
        s.ch = NULL;
    }
    s.length = 0;
    return 1;
}

status concat(String &t, String s1, String s2)
{
    int i, j;
    if(t.ch)
        free(t.ch);
    t.ch = (char *) malloc ((s1.length+s2.length+1) * sizeof(char));
    if(!t.ch) exit(0);
    for(i=0; i<s1.length; i++)
        t.ch[i] = s1.ch[i];
    t.length=s1.length+s2.length;
    for(i=0; i<s2.length; i++)
        t.ch[s1.length+i]=s2.ch[i];
    return 1;
}

status substring(String &sub, String s, int pos, int len)//用sub返回串s第pos个字符起长度为len的子串
{
    if(pos<1||pos>s.length||len<0||len>s.length-pos+1)
        return -1;
    if(sub.ch)
        free(sub.ch);
    if(!len)
    {
        sub.ch = NULL;
        sub.length = 0;
    }//空子串
    else
    {
        sub.ch = (char *) malloc (len * sizeof(char));
        int i;
        for(i=pos-1; i<pos+len-1; i++)
            sub.ch[i-pos+1]=s.ch[i];
        sub.length = len;
    }//完整子串
    return 1;
}

bool StrInsert (String &s,  int pos,  String &t)// 在串 S 的第 pos(1≤pos≤StrLength(S)＋1) 个字符之前插入串T
{

    int slen=strlength(s);
    int tlen=strlength(t);
    // 求串长
    String s1;
    s1.ch = (char *) malloc ((slen + 1) * sizeof(char));           // 设S1为辅助串空间
    if (pos < 1 || pos > slen+1)// 插入位置不合法;
        return -1;
    if (tlen>0)
    {
        int i=0, k=0;
        for(i=0; i<slen; i++)
            s1.ch[i] = s.ch[i];      // 暂存串S
        free(s.ch);
        s.ch = (char *) malloc ((slen + tlen + 1) * sizeof(char));   // 重新分配空间
        for ( i=0, k=0; i<pos-1; i++)
            s.ch[k++] = s1.ch[i];   // 保留插入位置之前的子串
        int j = 0;
        for(j=0; j<tlen; j++)
            s.ch[k++] = s.ch[j++];      // 插入t
        for(i=0; i<slen; i++)
            s.ch[k++] = s1.ch[i++];   // 复制插入位置之后的子串
        s.ch[k] ='\0';                       // 置串S的结束标志

    }
}

void printf(String s)
{
    int i;
    for(i=0; i<s.length; i++)
        printf("%c", s.ch[i]);
    printf("\n");
}


<pre name="code" class="cpp">int index(String &s, String &t, int pos)// t为非空串。若主串s中第 pos 个字符之后存在与t相等的子串，
// 则返回第一个这样的子串在S中的 位置，否则返回0
{
    if(pos>0)
    {
        int i=pos-1;
        int j=0;
        int tlen = strlength(t);
        int slen = strlength(s);
        for(j=0; j<tlen; j++)
        {
            if(s.ch[i+j]!=t.ch[j])
            {
                i++;
                j=-1;
            }//i后移，重新开始新一轮比较
            if(i+j>=slen)
            {
                break;
            
            }   
        }    
        if(j==tlen) //匹配成功
             return (i+1);
        else           //不存在和串t相同的子串
              return -1;
    }
        return -1; // 位置不合法，s中不存在与t相等的子串

 kmp算法实现字符串匹配

int next[n];
void getnext(str &s2)
{
    int i=0;
    next[0]=-1;
    int j=-1;
    while(i<s2.len)//自己跟自己匹配
    {
        if(j==-1||s2.ch[i]==s2.ch[j])
        {
            i++;
            j++;
            next[i]=j;  
        }
        else
            j=next[j];
    }
}

int index_kmp(str &s1, str &s2)
{
    getnext(s2);
    int i=0, j=0;
    while(i<s1.len&&j<s2.len)
    {
        if(j==-1||s1.ch[i]==s2.ch[j])//next[0]=-1||不失配
        {
            i++;
            j++;
        }    //继续比较后序字符
        else //若从除0之外的位置失配，s1的i指针不回溯， 从s2的k位置开始匹配
            j=next[j];
    }
    if(j>=s2.len) return i-s2.len+1;//子串结束， 说明匹配成功
    else
        return -1;
}