数据结构(C语言版 严蔚敏著)——串

关于串，下面只介绍堆分配存储的串。

· 由于堆分配存储结构的串既有顺序存储结构的特点，处理方便，操作中对串长

  又没有任何限制，更显灵活，因此在串处理的应用程序中也常被选用。

更char数组类似

下面直接贴代码：

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

typedef struct {
    char *ch;
    int length;
} HString;

int StrInsert(HString &S, int pos, HString T) {
    //在串S的第pos个字符之前插入串T
    if (pos < 1 || pos > S.length + 1)
        return 0;
    if (T.length) {
        //分配空间
        if (!(S.ch = (char *) realloc((S.ch), (S.length + T.length) * sizeof(char))))
            exit(0);
        // 为插入T，把pos后面的往后挪，腾出空间
        for (int i = S.length - 1; i < pos - 1; --i)
            S.ch[i + T.length] = S.ch[i];
        //插入
        for (int j = 0; j < T.length; ++j)
            S.ch[pos - 1 + j] = T.ch[j];
        S.length += T.length;
    }
    return 1;
}

int StrAssign(HString &T, char *chars) {
    //生成一个其值等于串常量chars的串T
    int i;
    //释放原有空间
    if (T.ch)
        free(T.ch);
    for (i = 0; chars[i]; ++i);//统计chars长度
    //空串
    if (!i) {
        T.ch = NULL;
        T.length = 0;
    } else {
        //一一复制，相当于拷贝一份
        if (!(T.ch = (char *) malloc(i * sizeof(char))))
            exit(0);
        T.length = i;
        for (; i > 0; i--)
            T.ch[i - 1] = chars[i - 1];
    }
    return 1;
}

int StrLength(HString S) {
    //返回S的元素个数，称为串的长度
    return S.length;
}

int StrCompare(HString S, HString T) {
    //S>T,则返回值>0；若S=T，则返回值=0；
    //若S<T，则返回值<0
    for (int i = 0; i < S.length && i < T.length; ++i) {
        if (S.ch[i] != T.ch[i])
            //返回此时不同字符的ASC码的差
            return S.ch[i] - T.ch[i];
    }
    return S.length - T.length;
}

int ClearString(HString &S) {
    //将S清为空串
    if (S.ch) {
        free(S.ch);
        S.ch = NULL;
    }
    S.length = 0;
    return 1;
}

int Concat(HString &T, HString S1, HString S2) {
    //用T返回由S1和S2连接而成的新串
    //释放旧空间
    if (T.ch)
        free(T.ch);
    //分配空间
    if (!(T.ch = (char *) malloc((S1.length + S2.length) * sizeof(char))))
        exit(0);
    //放入S1
    for (int i = 0; i < S1.length; ++i) {
        T.ch[i] = S1.ch[i];
    }
    //总长
    T.length = S1.length + S2.length;
    //放入S2
    for (int j = S1.length; j < T.length; ++j) {
        T.ch[j] = S2.ch[j - S1.length];
    }
    return 1;
}

int SubString(HString &Sub, HString S, int pos, int len) {
    //用Sub返回串S的第pos个字符起长度为len的字串
    //其中，1<=pos<=StrLength(S),且0<=len<=StrLength(S)-pos+1
    if (pos < 1 || pos > S.length || len < 0 || len > S.length - pos + 1)
        return 0;
    //释放旧空间
    if (Sub.ch)
        free(Sub.ch);
    //空子串
    if (!len) {
        Sub.ch = NULL;
        Sub.length = 0;
    } else {
        //分配空间
        Sub.ch = (char *) malloc(len * sizeof(char));
        //复制子串
        for (int i = 0; i < len; ++i) {
            Sub.ch[i] = S.ch[pos - 1 + i];
        }
        Sub.length = len;
    }
    return 1;
}