数据结构(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;
}