一步一步复习数据结构和算法基础-堆分配存储表示串

  在顺序存储结构中，实现串操作的元操作是“字符序列的复制”，操作的时间复杂度基于复制的字符序列的长度。

这个操作的特点就是如果操作中串的长度超过上界即 255 的时候就要进行截断处理，而且这个现象在串的其他

操作如插入、置换中也可能发生，克服这个弊病的方法唯有动态分配串的长度。

堆分配存储表示串基于这个思想：

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

在上面的结构体中 ch是字符串指针，可以根据需要开辟相应的空间，而且可以很方便的销毁。
下面就是部分基于堆分配存储表示串的操作：

#include<stdio.h>
#include<stdlib.h>
#define maxstrlen 255
typedef struct
{
char *ch;
int length;
}HString;

int StrAssign(HString *T,char *chars)
{
int i,k;
if((*T).ch)free((*T).ch);

i = strlen(chars);

if(!i){(*T).ch = NULL;(*T).length=0;}
else
{
if(!((*T).ch = (char*)malloc(sizeof(char)*i)))
exit(1);
for(k=0;k<i;k++)
(*T).ch[k]=chars[k];
(*T).length = i;
}

return 1;
}

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

//串比较：大于0 串S大于T 等于0 两串相等 小于0 串S小于T
int StrCompare(HString S,HString T)
{
int i;
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;
}

//销毁串T
int ClearStr(HString *T)
{
if(!(*T).ch){free((*T).ch);(*T).ch=NULL;}
(*T).length = 0;
return 1;
}

//连接串t1和t2
int StrConcat(HString *T,HString t1,HString t2)
{
int i,k;
if((*T).ch)free((*T).ch);
if(!((*T).ch = (char*)malloc(sizeof(char)*(t1.length + t2.length))))
exit(1);

(*T).length = t1.length + t2.length;
for(i=0,k=0;i<t1.length;i++,k++)
(*T).ch[k] = t1.ch[i];
for(i=0;i<t2.length;i++,k++)
(*T).ch[k]=t2.ch[i];

return 1;
}

//主串中获取字串
int SubString(HString *sub,HString T,int pos,int len)
{
int i;
if(pos < 1 || pos > T.length || len < 0 || len > T.length-pos+1)
return 0;
if((*sub).ch)free((*sub).ch);

if(!len){(*sub).ch = NULL;(*sub).length=0;}
else
{
(*sub).ch = (char*)malloc(sizeof(char)*len);
for(i=0;i<len;i++)
(*sub).ch[i] = T.ch[pos+i];
(*sub).length = len;
}
return 1;
}

int main()
{
return 0;
}