数据结构学习 串的表示和实现

在多数非数值处理的程序中，串也以变量的形式出现。

串有3种机内表示方法。

1、定长顺序存储表示

类似于线性表的顺序存储结构，用一组地址连续的存储单元存储串值的字符序列。再次存储结构中，按照预定义的大小，为每个定义的串变量分配一个固定长度的存储区，用定长数组描述之。

这种存储表示存在“截断”现象。

2、堆分配存储表示

以一组地址连续的存储单元存放串值字符序列，但他们的存储空间是在程序执行过程中动态分配而得。用动态分配函数malloc()和free()来管理这个称为“堆”的自由存储区。

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

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

Status StrInsert(HString *S,int pos,HString T)
{
//
int pos,i;
HString *S;
if(pos<1||pos>S.length+1)
return ERROR;
if(T.length){
if(!(S.ch=(char*)realloc(S.ch,(S.length+T.length)*sizeof(char))))
return OVERFLOW;
for(i=S.length-1;i>=pos-1;--i)
S.ch[i+T.length]=S.ch[i];
for(i=0;i<=T.length-1;i++)
S.ch[pos-1+i]=T.ch[i];
S.length+=T.length;
}
return OK;
}//StrInsert

//six functions
Status StrAssign(HString &T,char* chars)
{
    //生成一个其值等于串常量chars的串T
    int i,j;
    int* c;
    if(T.ch) free(T.ch);
    for(i=0,c=chars;c;++i,++c)
    ;
    if(!i){
       T.ch=NULL;
       T.length=0;
    }
    else{
        if(!(T.ch=(char*)malloc(i*sizeof(char))))
        return OVERFLOW;
        for(j=0;j<=i-1;j++)
        T.ch[j]=chars[j];
        T.length=i;
    }
    return OK;
}//StrAssign

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

int StrCompare(HString S,HString T)
{
    //若S>T,则返回值>0; 若S=T，则返回值=0；若S
   
   
    
    <0
    int i;
    for(i=0;i
    
    
     
     
      
      S.length||len<0||len>S.length-pos+1)
    return ERROR;
    if(Sub.ch) free(S.ch);
    if(!len) {
        Sub.ch=NULL;Sub.length=0;}//kong
        else
        {
            Sub.ch=(char*)malloc(len*sizeof(char));
            for(i=0;i<=len-1;i++)
            Sub.ch[i]=S.ch[pos-1+i];
            Sub.length=len;
        }
    return OK;
}//SubString

     
     
    
    
   
   

3、串的块链存储表示

和线性表的链式存储结构相类似，也可采用链表方式存储串值。用链表存储串值时，存在一个“节点大小”的问题，即每个节点可以存放一个字符，也可以存放多个字符。

为便于操作，当以链表存储串值时，除头指针外还可附设一个尾指针指示链表中的最后一个节点，并给出当前串的长度。成如此定义的结构为块链结构。

//————串的块链存储表示————
#define CHUNKSIZE 80    //自定义的块大小
struct Chunk{
char ch[CHUNKSIZE];
struct Chunk *next;
};

typedef struct Chunk{
char ch[CHUNKSIZE];
struct Chunk *next;
}Chunk;
typedef struct{
Chunk *head,*tail;   //头指针和尾指针
int curlen;  //串的当前长度
}LString;

进行联接操作时，需处理第一个串尾的无效字符。

在各种串的处理系统中，所处理的串往往很长或很多，所以我们需要考虑串值的存储密度。存储密度定义为：存储密度=串值所占的存储位/实际分配的存储位。存储密度小，处理方便，但存储占用量大。

另外，串的字符集的大小也是一个重要因素。一般地，字符集小，则字符的机内编码就短，这也影响串值的存储方式的选取。