串->串的表示和实现

文字描述：

串，就是字符串的意思。在数据结构中，串的存储方式有三种：定长顺序存储表示、堆分配存储表示和块链存储表示:

定长顺序存储表示:  以一组地址连续的存储单元存放字符序列，按照预定义的大小，为每个定义的串变量分配一个固定长度的存储区。超出预定义的串值会被舍弃，成为“截断”。

堆分配存储表示: 以一组地址连续的存储单元存放字符序列，但它们的存储空间是在执行时动态分配而得。

块链存储表示: 和线性表的链式存储结构类似，如下图，一个是结点大小为1的链表，一个是结点大小为4的链表；在链式存储方式中，结点大小的选择很重要，太小的话，虽然运算方便但是存储占用量大；如果太大的话，会太浪费空间。另外，它除了连接字串方便外，其他也不如前面两种存储方式灵活，一般都不用。

串的求子串的定位函数：返回子串在主串中的位置。

方法一，通用做法，如下图主串位置在匹配过程中可能会后退

方法二：模式匹配的一种改进算法KMP。主串匹配的下标一直前进，没有后退。关于这个算法，虽然KMP实现的代码很短，还是并不容易理解，可以参考下https://www.cnblogs.com/ZuoAndFutureGirl/p/9028287.html

方法三：优化后的KMP。按照方法二的KMP算法，在某些情况下是有缺陷的，比如主串为“aaabaaaab”, 子串为”aaaab”的时候，匹配时，当i=4、j=3时，S.ch[4] != T.ch[4]，有next[j]指示还需进行i=4,j=3; i=4,j=2; i=4,j=1这3次比较。显然j=3、2、1都为’a’，和主串中i=4的比较结果都是一样的，可以将模式一气向右滑动4个字读的位置直接进行i=5、j=1的字符比较。

算法分析：

一般方法求子串在主串中的位置下标的时间复杂度为n*m

而KMP算法求子串在主串中的位置下标的时间复杂度为n+m， 另外在KMP中求串的next函数值的算法的时间复杂度为m。

代码实现：

串的定长顺序表示

//
// Created by Zhenjie Yu on 2019-04-14.
//

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

#define DEBUG
#ifdef DEBUG
#include <stdarg.h>
#define LOG(args...) _log_(__FILE__, __FUNCTION__, __LINE__, ##args);
static void _log_(const char *file, const char *function, int line, const char * format, ...)
{
    char buf[1024] = {0};
    va_list list;
    va_start(list, format);
    vsprintf(buf+strlen(buf), format, list);
    sprintf(buf+strlen(buf), "
");
    va_end(list);
    printf(buf);
}
#else
#define LOG
#endif // DEBUG

#define MAX_STRING 255
typedef unsigned char SString[MAX_STRING+1]; //第一位表示串长

static int Concat(SString T, SString S1, SString S2){
    int uncut = -1;
    if(S1[0]+S2[0] <= MAX_STRING){
        snprintf(T+1, S1[0]+1, "%s", S1+1);
        snprintf(T+1+S1[0], S2[0]+1, "%s", S2+1);
        T[0] = S1[0] + S2[0];
        uncut = 1;
    }else if(S1[0] < MAX_STRING){
        snprintf(T+1, S1[0]+1, "%s", S1+1);
        snprintf(T+1+S1[0], MAX_STRING-S1[0]+1, "%s", S2+1);
        T[0] = MAX_STRING;
        uncut = 0;
    }else{
        snprintf(T+1, MAX_STRING+1, "%s", S1+1);
        T[0] = MAX_STRING;
        uncut = 0;
    }
    return uncut;
}

static int StrAssign(SString T, const char chars[]){
    memset(T, 0, MAX_STRING+1);
    int len = strlen(chars);
    if(len > MAX_STRING){
        return -1;
    }
    T[0] = len;
    snprintf(T+1, len+1, "%s", chars);
    return 0;
}

static int SubString(SString Sub, SString S, int pos, int len)
{
    if(pos<1 || pos>S[0] || len<0 || len>(S[0]-pos+1)){
        return -1;
    }
    snprintf(Sub+1, len+1, S+pos);
    Sub[0] = len;
    return 0;
}

int main(int argc, char *arg)
{
    SString S1, S2, T, Sub;
    int ret = -1;

    StrAssign(S1, "test123");
    LOG("设置串S1的值为%s, 长度为%d", S1+1, S1[0]);

    StrAssign(S2, "abcdef");
    LOG("设置串S2的值为%s, 长度为%d", S2+1, S2[0]);

    ret = Concat(T, S1, S2);
    LOG("连接串S1和S2,并保存到变量T中，连接后T为%s, T的长度为%d", T+1, T[0]);

    ret = SubString(Sub, T, 4, 6);
    LOG("求主串T中，起始地址为4,长度为6的子串，子串结果保存咋变量Sub中; Sub的值为%s,长度为%d", Sub+1, Sub[0]);
    return 0;
}

/home/lady/CLionProjects/untitled/cmake-build-debug/untitled
设置串S1的值为test123, 长度为7
设置串S2的值为abcdef, 长度为6
连接串S1和S2,并保存到变量T中，连接后T为test123abcdef, T的长度为13
求主串T中，起始地址为4,长度为6的子串，子串结果保存咋变量Sub中; Sub的值为t123ab,长度为6

Process finished with exit code 0

串的堆分配存储表示及其模式匹配算法

//
// Created by Zhenjie Yu on 2019-04-14.
//

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

#define DEBUG
#ifdef DEBUG
#include <stdarg.h>
#define LOG(args...) _log_(__FILE__, __FUNCTION__, __LINE__, ##args);
static void _log_(const char *file, const char *function, int line, const char * format, ...)
{
    char buf[1024] = {0};
    va_list list;
    va_start(list, format);
    vsprintf(buf+strlen(buf), format, list);
    sprintf(buf+strlen(buf), "
");
    va_end(list);
    printf(buf);
}
#else
#define LOG
#endif // DEBUG


typedef struct HString{
    char *ch;  //如果是空串，就为NULL；否则按串长分配存储区
    int length; //串长度
}HString;

//生成一个其值等于串常量chars的串T
static int StrAssign(HString *T, const char *chars);
//返回S的元素个数，称为串的长度
static int StrLength(HString S);
//如果S大于T，则返回正值; 如果S等于T，则返回0; 否则返回负值
static int StrCompare(HString S, HString T);
//将S清为空串
static int ClearString(HString *S);
//用T返回由S1和S2连接而成的新串
static int Concat(HString *T, HString S1, HString S2);
//用Sub返回串S的第pos个字符起长度为Len的子串
static int SubString(HString *Sub, HString S, int pos, int len);

//返回子串T在主串S中第pos个字符之后的位置。若不存在，则函数值为0;
static int Index(HString S, HString T, int pos){
    if(pos<0 || pos>=S.length){
        return -1;
    }
    int i = pos, j = 0;
    while(i<S.length && j<T.length){
        LOG("普通方法: 比较S.ch[%d]=%c 和 T.ch[%d]=%c", i, S.ch[i], j, T.ch[j]);
        if(S.ch[i] == T.ch[j]){
            i += 1;
            j += 1;
        }else{
            i = i-j+1;
            j = 0;
            LOG("普通方法: 两者不等，需把S的下标i回退到%d, 把T的下标j回退到%d", i, j);
        }
    }
    if(j>=T.length){
        return i-T.length;
    }else{
        return 0;
    }
}



/*********************使用KMP算法求子串位置的定位函数************************/
void get_next(HString T, int next[]){
    int i = 1;
    int j = 0;
    memset(next, 0, T.length);
    next[1] = 0;
    int count = 1;
    while(i<T.length){
        count += 1;
        if(j == 0 || T.ch[i-1] == T.ch[j-1]){
            ++i;
            ++j;
            next[i] = j;
        }else{
            j = next[j];
        }
    }

    for(i=1; i<=T.length; i++){
        if(next[i]){
            next[i] = next[i]-1;
        }
        next[i-1] = next[i];
    }

    for(i=0; i<T.length; i++){
        LOG("KMP算法中字串(%s)的next函数值: next[%d]=%d", T.ch, i, next[i]);
    }
}
//https://www.cnblogs.com/ZuoAndFutureGirl/p/9028287.html
static int Index_KMP(HString S, HString T, int pos){
    if(pos<0 || pos>=S.length){
        return -1;
    }
    int i = 0;
    int j = 0;
    int *next = (int*)malloc(sizeof(int)*T.length+1);

    get_next(T, next);

    i = pos;
    j = 0;
    while(i<S.length && j<T.length){
        LOG("用KMP方法: 比较S.ch[%d]=%c 和 T.ch[%d]=%c", i, S.ch[i], j, T.ch[j]);
        if(S.ch[i] == T.ch[j] || j == 0){
            i += 1;
            j += 1;
        }else{
            j = next[j];
            LOG("用KMP方法: 两者不等，需把S的下标i保持不变, 把T的下标j回退到%d", j);
        }
    }

    free(next);
    if(j>=T.length){
        //匹配成都
        return i-T.length;
    }else{
        return 0;
    }
}


/*********************使用优化后的KMP算法求子串位置的定位函数************************/
void get_next_Val(HString T, int nextval[])
{
    memset(nextval, 0, T.length+1);
    int i = 1;
    int j = 0;
    nextval[1] = 0;
    while (i<T.length){
        if(j==0 || T.ch[i-1] == T.ch[j-1]){
            i += 1;
            j += 1;
            if(j && (T.ch[i-1] != T.ch[j-1])){
                nextval[i] = j;
            }else{
                nextval[i] = nextval[j];
            }
        }else{
            j = nextval[j];
        }
    }

    for(i=1; i<=T.length; i++){
        if(nextval[i]){
            nextval[i] = nextval[i]-1;
        }
        nextval[i-1] = nextval[i];
    }

    for(i=0; i<T.length; i++){
        LOG("优化后的KMP算法中字串(%s)的nextval函数值: nextval[%d]=%d", T.ch, i, nextval[i]);
    }
    return ;
}
static int Index_KMP_Val(HString S, HString T, int pos)
{
    if(pos<0 || pos>=S.length){
        return -1;
    }
    int i = 0;
    int j = 0;
    int *next = (int*)malloc(sizeof(int)*T.length+1);

    get_next_Val(T, next);

    i = pos;
    j = 0;
    while(i<S.length && j<T.length){
        LOG("用优化后的KMP方法: 比较S.ch[%d]=%c 和 T.ch[%d]=%c", i, S.ch[i], j, T.ch[j]);
        if(S.ch[i] == T.ch[j] || j == 0){
            i += 1;
            j += 1;
        }else{
            j = next[j];
            LOG("用优化后的KMP方法: 两者不等，需把S的下标i保持不变, 把T的下标j回退到%d", j);
        }
    }
    free(next);
    if(j>=T.length){
        //匹配成都
        return i-T.length;
    }else{
        return 0;
    }
}



int main(int argc, char *argv[])
{
    int ret = -1;
    int pos = 0;
    HString S1, S2, T, Sub, S;
    S1.ch = S2.ch = T.ch = Sub.ch = S.ch = NULL;
    S1.length = S2.length = T.length = Sub.length = 0;

    ret = StrAssign(&S1, "hbcde");
    LOG("设置变量S1为%s", S1.ch);

    ret = StrAssign(&S2, "ghijklm");
    LOG("设置变量S2为%s", S2.ch);

    ret = StrCompare(S1, S2);
    LOG("较字符串S1和S2的大小, 返回值为%d", ret);

    ret = Concat(&T, S1, S2);
    LOG("将字符串S1和S2拼接，并将值保存到T; 结果使得变量T为%s", T.ch);

    ret = SubString(&Sub, T, 4, 3);
    LOG("求字符串T中起始4开始、长度为3的子串，并将子串放到变量Sub; 结果使得变量Sub为%s, （下标从1开始）", Sub);

    LOG("清空S1、S2、T、Sub变量的内容");
    ClearString(&S1);
    ClearString(&S2);
    ClearString(&T);
    ClearString(&Sub);

    ret = StrAssign(&S, "acabaabaabcacaabc");
    LOG("设置变量S为%s", S.ch);

    ret = StrAssign(&T, "abaabc");
    LOG("设置变量T为%s", T.ch);

    LOG("求字串S中位置pos开始，是否存在子串T; 如果存在，则返回字串T在S中的位置下标");
    LOG("方法一：普通方法");
    ret = Index(S, T, pos);
    LOG("普通方法: 求字串S(%s)中位置pos(%d)开始，是否存在子串T(%s); 返回的下标为%d (下标从0开始)
", S.ch, pos, T.ch, ret);

    LOG("方法二：用KMP方法，例1");
    ret = Index_KMP(S, T, pos);
    LOG("用KMP方法，例1: 求字串S(%s)中位置pos(%d)开始，是否存在子串T(%s); 返回的下标为%d (下标从0开始)
", S.ch, pos, T.ch, ret);

    ret = StrAssign(&S, "aaabaaaab");
    LOG("设置变量S为%s", S.ch);

    ret = StrAssign(&T, "aaaab");
    LOG("设置变量T为%s", T.ch);

    LOG("方法二：用KMP方法，例2");
    ret = Index_KMP(S, T, pos);
    LOG("用KMP方法，例2: 求字串S(%s)中位置pos(%d)开始，是否存在子串T(%s); 返回的下标为%d (下标从0开始)
", S.ch, pos, T.ch, ret);


    LOG("方法三：用改进后的KMP方法");
    ret = Index_KMP_Val(S, T, pos);
    LOG("用改进后的KMP方法: 求字串S(%s)中位置pos(%d)开始，是否存在子串T(%s); 返回的下标为%d (下标从0开始)", S.ch, pos, T.ch, ret);
    return 0;
}



//////////////////////////////////////////////////////////////////////////
static int StrAssign(HString *T, const char *chars)
{
    if(T == NULL){
        return -1;
    }
    if(T->ch){
        free(T->ch);
        T->ch = NULL;
    }
    int len = strlen(chars);
    if((T->ch = malloc(len+1)) == NULL){
        return -1;
    }
    memset(T->ch, 0, len+1);
    T->length = len;
    snprintf(T->ch, len+1, "%s", chars);
    return 0;
}

static int StrLength(HString S)
{
    return S.length;
}

static int StrCompare(HString S, HString 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;
}

static int ClearString(HString *S)
{
    if(S->ch){
        free(S->ch);
        S->ch = NULL;
    }
    S->length = 0;
    return 0;
}
static int Concat(HString *T, HString S1, HString S2)
{
    if(T->ch){
        free(T->ch);
        T->ch = NULL;
    }
    if((T->ch = (char*)malloc((S1.length+S2.length)*sizeof(char))) == NULL){
        return -1;
    }
    strncpy(T->ch, S1.ch, S1.length);
    strncpy(T->ch+S1.length, S2.ch, S2.length);
    T->length = S1.length + S2.length;
    T->ch[T->length] = '';
    return 0;
}

static int  SubString(HString *Sub, HString S, int pos, int len)
{
    if(pos<1 || pos>S.length || len<0 || len>S.length-pos+1){
        return -1;
    }
    if(Sub->ch){
        free(Sub->ch);
        Sub->ch = NULL;
    }
    if(!len){
        Sub->ch = NULL;
        Sub->length = 0;
    }else{
        Sub->ch = (char *)malloc(len*sizeof(char)+1);
        memset(Sub->ch, 0, len);
        strncpy(Sub->ch, S.ch+pos-1, len);
        Sub->length = len;
        Sub->ch[len] = '';
    }
    return 0;
}

/home/lady/CLionProjects/untitled/cmake-build-debug/untitled
设置变量S1为hbcde
设置变量S2为ghijklm
较字符串S1和S2的大小, 返回值为1
将字符串S1和S2拼接，并将值保存到T; 结果使得变量T为hbcdeghijklm
求字符串T中起始4开始、长度为3的子串，并将子串放到变量Sub; 结果使得变量Sub为deg, （下标从1开始）
清空S1、S2、T、Sub变量的内容
设置变量S为acabaabaabcacaabc
设置变量T为abaabc
求字串S中位置pos开始，是否存在子串T; 如果存在，则返回字串T在S中的位置下标
方法一：普通方法
普通方法: 比较S.ch[0]=a 和 T.ch[0]=a
普通方法: 比较S.ch[1]=c 和 T.ch[1]=b
普通方法: 两者不等，需把S的下标i回退到1, 把T的下标j回退到0
普通方法: 比较S.ch[1]=c 和 T.ch[0]=a
普通方法: 两者不等，需把S的下标i回退到2, 把T的下标j回退到0
普通方法: 比较S.ch[2]=a 和 T.ch[0]=a
普通方法: 比较S.ch[3]=b 和 T.ch[1]=b
普通方法: 比较S.ch[4]=a 和 T.ch[2]=a
普通方法: 比较S.ch[5]=a 和 T.ch[3]=a
普通方法: 比较S.ch[6]=b 和 T.ch[4]=b
普通方法: 比较S.ch[7]=a 和 T.ch[5]=c
普通方法: 两者不等，需把S的下标i回退到3, 把T的下标j回退到0
普通方法: 比较S.ch[3]=b 和 T.ch[0]=a
普通方法: 两者不等，需把S的下标i回退到4, 把T的下标j回退到0
普通方法: 比较S.ch[4]=a 和 T.ch[0]=a
普通方法: 比较S.ch[5]=a 和 T.ch[1]=b
普通方法: 两者不等，需把S的下标i回退到5, 把T的下标j回退到0
普通方法: 比较S.ch[5]=a 和 T.ch[0]=a
普通方法: 比较S.ch[6]=b 和 T.ch[1]=b
普通方法: 比较S.ch[7]=a 和 T.ch[2]=a
普通方法: 比较S.ch[8]=a 和 T.ch[3]=a
普通方法: 比较S.ch[9]=b 和 T.ch[4]=b
普通方法: 比较S.ch[10]=c 和 T.ch[5]=c
普通方法: 求字串S(acabaabaabcacaabc)中位置pos(0)开始，是否存在子串T(abaabc); 返回的下标为5 (下标从0开始)

方法二：用KMP方法，例1
KMP算法中字串(abaabc)的next函数值: next[0]=0
KMP算法中字串(abaabc)的next函数值: next[1]=0
KMP算法中字串(abaabc)的next函数值: next[2]=0
KMP算法中字串(abaabc)的next函数值: next[3]=1
KMP算法中字串(abaabc)的next函数值: next[4]=1
KMP算法中字串(abaabc)的next函数值: next[5]=2
用KMP方法: 比较S.ch[0]=a 和 T.ch[0]=a
用KMP方法: 比较S.ch[1]=c 和 T.ch[1]=b
用KMP方法: 两者不等，需把S的下标i保持不变, 把T的下标j回退到0
用KMP方法: 比较S.ch[1]=c 和 T.ch[0]=a
用KMP方法: 比较S.ch[2]=a 和 T.ch[1]=b
用KMP方法: 两者不等，需把S的下标i保持不变, 把T的下标j回退到0
用KMP方法: 比较S.ch[2]=a 和 T.ch[0]=a
用KMP方法: 比较S.ch[3]=b 和 T.ch[1]=b
用KMP方法: 比较S.ch[4]=a 和 T.ch[2]=a
用KMP方法: 比较S.ch[5]=a 和 T.ch[3]=a
用KMP方法: 比较S.ch[6]=b 和 T.ch[4]=b
用KMP方法: 比较S.ch[7]=a 和 T.ch[5]=c
用KMP方法: 两者不等，需把S的下标i保持不变, 把T的下标j回退到2
用KMP方法: 比较S.ch[7]=a 和 T.ch[2]=a
用KMP方法: 比较S.ch[8]=a 和 T.ch[3]=a
用KMP方法: 比较S.ch[9]=b 和 T.ch[4]=b
用KMP方法: 比较S.ch[10]=c 和 T.ch[5]=c
用KMP方法，例1: 求字串S(acabaabaabcacaabc)中位置pos(0)开始，是否存在子串T(abaabc); 返回的下标为5 (下标从0开始)

设置变量S为aaabaaaab
设置变量T为aaaab
方法二：用KMP方法，例2
KMP算法中字串(aaaab)的next函数值: next[0]=0
KMP算法中字串(aaaab)的next函数值: next[1]=0
KMP算法中字串(aaaab)的next函数值: next[2]=1
KMP算法中字串(aaaab)的next函数值: next[3]=2
KMP算法中字串(aaaab)的next函数值: next[4]=3
用KMP方法: 比较S.ch[0]=a 和 T.ch[0]=a
用KMP方法: 比较S.ch[1]=a 和 T.ch[1]=a
用KMP方法: 比较S.ch[2]=a 和 T.ch[2]=a
用KMP方法: 比较S.ch[3]=b 和 T.ch[3]=a
用KMP方法: 两者不等，需把S的下标i保持不变, 把T的下标j回退到2
用KMP方法: 比较S.ch[3]=b 和 T.ch[2]=a
用KMP方法: 两者不等，需把S的下标i保持不变, 把T的下标j回退到1
用KMP方法: 比较S.ch[3]=b 和 T.ch[1]=a
用KMP方法: 两者不等，需把S的下标i保持不变, 把T的下标j回退到0
用KMP方法: 比较S.ch[3]=b 和 T.ch[0]=a
用KMP方法: 比较S.ch[4]=a 和 T.ch[1]=a
用KMP方法: 比较S.ch[5]=a 和 T.ch[2]=a
用KMP方法: 比较S.ch[6]=a 和 T.ch[3]=a
用KMP方法: 比较S.ch[7]=a 和 T.ch[4]=b
用KMP方法: 两者不等，需把S的下标i保持不变, 把T的下标j回退到3
用KMP方法: 比较S.ch[7]=a 和 T.ch[3]=a
用KMP方法: 比较S.ch[8]=b 和 T.ch[4]=b
用KMP方法，例2: 求字串S(aaabaaaab)中位置pos(0)开始，是否存在子串T(aaaab); 返回的下标为4 (下标从0开始)

方法三：用改进后的KMP方法
优化后的KMP算法中字串(aaaab)的nextval函数值: nextval[0]=0
优化后的KMP算法中字串(aaaab)的nextval函数值: nextval[1]=0
优化后的KMP算法中字串(aaaab)的nextval函数值: nextval[2]=0
优化后的KMP算法中字串(aaaab)的nextval函数值: nextval[3]=0
优化后的KMP算法中字串(aaaab)的nextval函数值: nextval[4]=3
用优化后的KMP方法: 比较S.ch[0]=a 和 T.ch[0]=a
用优化后的KMP方法: 比较S.ch[1]=a 和 T.ch[1]=a
用优化后的KMP方法: 比较S.ch[2]=a 和 T.ch[2]=a
用优化后的KMP方法: 比较S.ch[3]=b 和 T.ch[3]=a
用优化后的KMP方法: 两者不等，需把S的下标i保持不变, 把T的下标j回退到0
用优化后的KMP方法: 比较S.ch[3]=b 和 T.ch[0]=a
用优化后的KMP方法: 比较S.ch[4]=a 和 T.ch[1]=a
用优化后的KMP方法: 比较S.ch[5]=a 和 T.ch[2]=a
用优化后的KMP方法: 比较S.ch[6]=a 和 T.ch[3]=a
用优化后的KMP方法: 比较S.ch[7]=a 和 T.ch[4]=b
用优化后的KMP方法: 两者不等，需把S的下标i保持不变, 把T的下标j回退到3
用优化后的KMP方法: 比较S.ch[7]=a 和 T.ch[3]=a
用优化后的KMP方法: 比较S.ch[8]=b 和 T.ch[4]=b
用改进后的KMP方法: 求字串S(aaabaaaab)中位置pos(0)开始，是否存在子串T(aaaab); 返回的下标为4 (下标从0开始)

Process finished with exit code 0