数据结构（三）串---KMP模式匹配算法实现及优化

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 40

typedef int ElemType;
typedef int Status;

//设置串的存储结构
typedef char String[MAXSIZE+1];

//生成串相关
Status StrAssign(String S,char *chars);    //生成一个其值等于字符串常量的chars的串T
Status StrCopy(String T, String S);        //串S存在，由串S复制得到串T
Status Concat(String T, String S1, String S2);                //用T返回由S1和S2连接而成的新串

//基础操作相关
Status ClearString(String S);     //串S存在，将串清空
Status StringEmpty(String S);     //若串为空，返回true，否则false
int StringLength(String S);     //返回串S的元素个数，长度

//比较串，索引串相关
int StrCompare(String S, String T);            //若S > T返回 > 0, = 返回0， < 返回 < 0
Status SubString(String Sub, String S,int pos,int len); //串S存在，返回S由pos起，长度为len的子串到Sub
int Index(String S, String T,int pos);                //主串S，子串T，返回T在S中位置

//增删改相关
Status Replace(String S, String T, String V);        //串S，T和V存在，T非空，用V替换主串S中T串
Status StrInsert(String S, int pos, String T);    //在主串S中的pos位置插入串T
Status StrDelete(String S,int pos,int len);    //串S存在，从串S中删除第pos个字符串起长度为len的子串

void PrintStr(String S);


//生成串相关
//生成一个其值等于字符串常量的chars的串T
Status StrAssign(String S, char *chars)
{
    int i;
    if (strlen(chars) > MAXSIZE)
        return ERROR;
    else
    {
        S[0] = strlen(chars);
        for (i = 1; i <= S[0];i++)
            S[i] = *(chars+i-1);
        return OK;
    }
}

//串S存在，由串S复制得到串T
Status StrCopy(String T, String S)
{
    int i;
    for (i = 0; i <= S[0];i++)
        T[i] = S[i];
    return OK;
}

//用T返回由S1和S2连接而成的新串,若是超出，会截断，但是会进行连接，返回FALSE
Status Concat(String T, String  S1, String S2)
{
    int i,j,interLen;    //interLen是截断后S2剩余长度

    if (S1[0] + S2[0] > MAXSIZE)
        interLen = MAXSIZE - S1[0];
    else
        interLen = S2[0];

    T[0] = S1[0] + S2[0];
    for (i = 1; i <= S1[0]; i++)
        T[i] = S1[i];
    for (j = 1; j <= interLen; j++)
        T[i+j-1] = S2[j];
    if (interLen != S2[0])
        return ERROR;
    return OK;
}

//基础操作相关
//串S存在，将串清空
Status ClearString(String S)
{
    S[0] = 0;
    return OK;
}

//若串为空，返回true，否则false
Status StringEmpty(String S)
{
    if (S[0] != 0)
        return FALSE;
    return TRUE;
}

//返回串S的元素个数，长度
int StringLength(String S)
{
    return S[0];
}

//比较串，索引串相关
//若S > T返回 > 0, = 返回0， < 返回 < 0
int StrCompare(String S, String T)
{
    int i;
    for (i = 1; i <= S[0] && i <= T[0]; i++)
        if (S[i] != T[i])
            return S[i] - T[i];
    return S[0]-T[0];    //若是相同比较长度即可
}

//串S存在，返回S由pos起，长度为len的子串到Sub
Status SubString(String Sub, String S, int pos,int len)
{
    int i;
    if (pos<1 || len<0 || pos + len - 1 > S[0] || pos>S[0])
        return ERROR;
    for (i = 0; i < len;i++)
        Sub[i + 1] = S[pos + i];
    Sub[0] = len;
    return OK;
}

//主串S，子串T，返回T在S中位置,pos代表从pos开始匹配
//或者一次截取一段进行比较为0则找到
int Index(String S, String T, int pos)
{
    int i, j;
    i = pos;
    j = 1;
    while (i<=S[0]-T[0]+1&&j<=T[0])
    {
        if (S[i]==T[j])
        {
            j++;
            i++;
        }
        else
        {
            i = i - j + 2;    //注意这个索引的加2
            j = 1;
        }
    }
    if (j > T[0])
        return i - T[0];
    return 0;
}

//增删改相关
//串S，T和V存在，T非空，用V替换主串S中T串
Status Replace(String S, String T, String V)
{
    int idx=1;
    if (StringEmpty(T))
        return ERROR;

    while (idx)
    {
        idx = Index(S, T, idx);
        if (idx)
        {
            StrDelete(S, idx, StringLength(T));
            StrInsert(S, idx, V);
            idx += StringLength(V);
        }
    }
    return OK;
}

//在主串S中的pos位置插入串T，注意：若是串满，则只插入部分
Status StrInsert(String S, int pos, String T)
{
    int i,interLength;
    if (S[0] + T[0] > MAXSIZE)    //长度溢出
        interLength = MAXSIZE - S[0];
    else
        interLength = T[0];

    for (i = S[0]; i >= pos;i--)
        S[interLength + i] = S[i];    //将后面的数据后向后移动

    //开始插入数据
    for (i = 1; i <= interLength; i++)
        S[pos + i - 1] = T[i];

    S[0] += interLength;

    if (interLength != T[0])
        return ERROR;
    return OK;
}

//串S存在，从串S中删除第pos个字符串起长度为len的子串
Status StrDelete(String S, int pos,int len)
{
    int i;
    if (pos < 1 || len<1 || pos + len - 1>S[0])
        return ERROR;

    //将数据前移
    for (i = pos+len; i <= S[0];i++)
        S[i-len] = S[i];

    S[0] -= len;
    return OK;
}

void PrintStr(String S)
{
    int i;
    for (i = 1; i <= StringLength(S);i++)
    {
        printf("%c", S[i]);
    }
    printf("\n");
}

int main()
{
    int i, j;
    String s1,s2,t;
    
    char *str = (char*)malloc(sizeof(char) * 40);
    memset(str, 0, 40);
    printf("enter s1:");
    scanf("%s", str);
    if (!StrAssign(s1, str))
        printf("1.string length is gt %d\n", MAXSIZE);
    else
        printf("1.string StrAssign success\n");

    printf("enter s2 to match:");
    scanf("%s", str);
    if (!StrAssign(s2, str))
        printf("1.string length is gt %d\n", MAXSIZE);
    else
        printf("1.string StrAssign success\n");
    
    i = Index_KMP(s1, s2, 1);
    printf("index:%d", i);

    system("pause");
    return 0;
}