第四章（3）.块链存储表示

 //用链表存储串值时，存在一个“结点大小”的问题，即每个结点可以存放一个字符，也可以
//存放多个字符
//当结点大小大于1时，由于串长不一定是结点大小的整倍数，则链表中的最后一个节点不一定
//完全被串值占满,此时通常补上“#”或其他的非串值字符(“#”是个特殊符号)
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define CHUNKSIZE 4   //由用户定义块的大小
typedef struct  Chunk    //链表结点,块结点
{
 char ch[CHUNKSIZE];    //每个结点存放的串
 struct Chunk *next;
}Chunk;
typedef struct
{
 Chunk *head ,*tail;   //设置尾指针，便于进行连接操作，但应注意连接时处理第一个串尾的无效字符。整体不如另外两种存储结构灵活，占用空间大且操作复杂
 int curlen;     //串的当前长度，即为字符数，而不是块数
}LString;
//一般情况下，对串操作只需要从头到尾顺序扫描即可，则对串值不必建立双向链表
void InitLString(LString *T)
{
 (*T).curlen = 0;
 (*T).head = (*T).tail = NULL;
}
void StrAssign(LString *T, char *chars)
{     //生成一个其值等于chars的串T(要求chars中不包含填补空余的字符)
 int i,j,k,m;
    Chunk *p,*q;
 
    i = strlen(chars);    //i为字符数
 
 //串长为0或chars中包含填补空余的字符
 if(!i || strchr(chars, ' ' ))    //strchr(char *ch, char c)  返回ch中第一次出现c的位置，如不存在则返回NULL
 {
  exit(0);
 }
    (*T).curlen = i;
 
 j = i/CHUNKSIZE;      //j为结点数，即为块数
 if(i%CHUNKSIZE)
 {
  ++j;
 }
 
 for(k = 0; k < j; ++k)
 {
  p = (Chunk *)malloc(sizeof(Chunk));   //生成块结点
  if(!p)
  {
   exit(0);
  }
  
  for(m = 0; m < CHUNKSIZE && *chars; ++m)
  {
   *(p->ch + m) = *chars++;   // p->ch[m]
  }
  
  if(k == 0)      //第一个结点(链块)
  {
   (*T).head = q = p;
  }
  else            //其他结点(链块)  (包括最后一个结点)
  {
   q->next = p;
   q = p;
  }
        
  //跳出原因如果是*chars不存在，则如下。如果是 m = CHUNKSIZE,则继续循环
  if(!*chars)   //最后一个结点(链块)
  {
   (*T).tail = q;
   q->next = NULL;
   
   for( ; m < CHUNKSIZE; ++m)
   {
    *(q->ch + m) = ' ';
   }
  }
 }
}
void StrPrint(LString T)
{
 int i = 0,j;
 Chunk *p; 
 
 p = T.head;
 while( i < T.curlen && p )
 {
  for(j = 0; j < CHUNKSIZE; ++j)
  {
   if(*(p->ch + j) != ' ')
   {
    printf("%c",*(p->ch + j));
   }
  }
  p = p->next;
 }
 printf("\n");
}
int StrLength(LString T)
{
 return T.curlen;
}
int StrEmpty(LString T)
{
 if(T.curlen == 0)
 {
  return 1;
 }
 return 0;
}
void ClearLString(LString *T)
{
 // int i,j,k;
 Chunk *p,*q;
 
 /* i = (*T).curlen;
 j = i/CHUNKSIZE;   //块链数
 if(i%CHUNKSIZE)
 {
 ++j;
 }
 
   p = (*T).head->next;
   for( k = 0 ; k < j -1 ; ++k)
   {
   q = p->next;
   free(p);
   p = q;
   }
 free((*T).head); */
 
 p = (*T).head;   
 while(p)
 {
  q = p->next;
  free(p);     //可以从头结点开始释放
  p = q;
 }
 
 (*T).head = (*T).tail = NULL;
 (*T).curlen = 0;
}
//这个函数很重要，因为块链的其他操作如果仍以块链为单位的话，那可想而知会有多复杂，所以必须先把块链的字符转为字符串
int ToChars(LString T,char **chars)  //*chars为字符串，再指针*则是为了返回字符串首地址
{
 int i;
 char *q;
 Chunk *p = T.head;
 
 *chars = (char *)malloc((T.curlen + 1) * sizeof(char));   //take care! 为字符串申请空间
 if(!chars || !T.curlen)  //生成字符串数组失败或串T长为0 
 {
  exit(0);
 }
 q = *chars;  //q指向chars的第1个字符(注意此处的*chars为指向char的指针地址)
 
 while(p)
 {
  for(i = 0; i < CHUNKSIZE; ++i)
  {
   if(p->ch[i] != ' ')
   {
    *q++ = p->ch[i];
   }
  }
  p = p->next;
 }
 (*chars)[T.curlen] = 0;  //串结束，第T.curlen + 1个元素为结束符
 return 1;
}
void StrCopy(LString *T,LString S)
{   //将串S的内容复制给串T
 char **c;
 
 c = NULL;
 c = (char **)malloc(sizeof(char *));
 
 if(!ToChars(S,c))
 {
  exit(0);
 }
// printf("%s\n",*c);
 StrAssign(T,*c);
 free(c);
}
void Concat(LString *T, LString Sa, LString Sb)
{
 LString *Saa,*Sbb;
 Saa = NULL;   //一种方式
 Sbb = NULL; 
 Saa = (LString *)malloc(sizeof(LString));
 Sbb = (LString *)malloc(sizeof(LString));
// LString Saa,Sbb;     亦可！另一种方式。效果一样！
// InitLString(&Saa);
// InitLString(&Sbb);
 StrCopy(Saa, Sa);
 StrCopy(Sbb, Sb);
 
 (*T).curlen = Sa.curlen + Sb.curlen ;  //串字符数
 //(*T).curlen = (*Saa).curlen + (*Sbb).curlen ;  同上
 (*T).head = (*Saa).head;
 (*Saa).tail->next = (*Sbb).head;   //首尾相连
 (*T).tail = (*Sbb).tail;
}
void SubString(LString *Sub, LString T, int pos, int len)
{    //初始条件：串S存在，1<=pos<=T.curlen且0<=len<=T.curlen-pos+1;
 //操作结果：用Sub返回串T第pos个字符起长度为len的子串
/*   char **ch,**c;
   c = NULL;
   c = (char **)malloc(sizeof(char *));
  
   ch = NULL;       //one way!
   ch = (char **)malloc(sizeof(char *));   //one way!  麻烦
*/
   char *ch,*c;   //another way!
   if(!ToChars(T,&ch))
   {
    exit(0);
   }
  
   if( pos < 1 || pos >T.curlen || len < 0 || len >T.curlen - pos + 1)
   {
    exit(0);
   }  
   
   c = ch + pos - 1;    //*c指向串Sub的首地址   *c = *ch[pos-1];
  
   c[len] = 0;   //字符串中间不允许有‘0’,如果遇到，则表示字符串结尾。此处直接截掉的len以后的字符。
  
   StrAssign(Sub,c);
   free(ch);
}
int Index(LString T, LString S, int pos)
{     //初始条件：串T，S存在，串S非空， 1<= pos <= T.curlen
 //操作结果：若主串T中存在和串S相同的子串，则返回它在主串T中第pos个字符起第一次出现的位置，否则返回0；
 int i,n,m;
 LString *Sub;
 Sub = NULL;
 Sub = (LString *)malloc(sizeof(LString));
 
 if(pos < 1 || pos > T.curlen)
 {
  exit(0);
 }
 
 n = T.curlen;
 m = S.curlen;
 i = pos;
 
 while(i <= n - m + 1)
 {
  SubString(Sub, T, i, m);
  if(!StrCompare(*Sub,S))
  {
   return i;   
  }
  else
  {
   ++i;
  }
 }
 return 0;
}
int StrCompare(LString T,LString S)
{
 char **c,**ch;
 int i;
 
 c= NULL;
 ch = NULL;
 c = (char **)malloc(sizeof(char *));
 ch = (char **)malloc(sizeof(char *));
 if( !ToChars(T,c) || !ToChars(S,ch))
 {
  exit(0);
 }
 i = strcmp(*c,*ch);
 free(c);
 free(ch);
 return i;
}
void StrInsert(LString *T, int pos, LString S)
{       //在主串T的第pos个位置之前插入串S
 char **ch,**c;
 int i;
 
 ch = NULL;
 c = NULL;
 ch = (char **)malloc(sizeof(char *));
 c = (char **)malloc(sizeof(char *));
 if(pos < 1 || pos > (*T).curlen + 1)    //pos 可能是最后的结束符，所以要加1
 {
  exit(0);
 }
 
 if(!ToChars((*T),ch) || !ToChars(S,c))
 {
  exit(0);
 }
 
 //take care!
 *ch = (char *)realloc(*ch, ((*T).curlen + S.curlen + 1)*sizeof(char));  //多一个结束符
 if(! *ch)  //分配不成功
 {
  exit(0);
 }
 
 for(i = (*T).curlen; i >= pos - 1; --i)
 {
  (*ch)[i + S.curlen] = (*ch)[i];
 }
 for(i = 0; i < S.curlen; ++i)
 {
  (*ch)[i + pos - 1] = (*c)[i];
 }
 
 InitLString(T);
 StrAssign(T,*ch);
 free(ch);
 free(c);
}

void StrDelete(LString *T,int pos, int len)
{    //删除串T中第pos个字符起长度为len的字串 (第pos个字符下标为pos-1)
 int i;
 char **c;
 
 c = NULL;
 c = (char **)malloc(sizeof(char *));
 if(pos < 1 || pos > (*T).curlen - len + 1 || len < 0 )
 {
  exit(0);
 }
 if(!ToChars(*T,c))
 {
  exit(0);
 }
 
 for( i = pos + len - 1; i <= (int)strlen(*c); ++i)   
 {
  (*c)[i - len] = (*c)[i];   //直接掩盖
 }
 
 InitLString(T);   //释放T的原有存储空间
 StrAssign(T,*c);   //由*c生成新的串T
 free(c);
}
void Replace(LString *T,LString Sa,LString Sb)
{   //初始条件：串L,Sa,Sb存在,Sa是非空串
 //操作结果：用Sb替换主串T中出现的所有与Sa相等的不重叠的子串
 int i = 1;
 
 if(StrEmpty(Sa))
 {
  exit(0);
 }
 
 do
 {
  i = Index( *T, Sa, i);
  if(i)
  {
   StrDelete(T, i, Sa.curlen);
   StrInsert(T, i, Sb);
   i += Sb.curlen;
  }
 }while(i);
}
void main(void)
{
 LString *T,*S,*F,*Sub;
 char *chars, ch[256] = "abcdef" ;
 
 chars = ch;
 T = NULL;
 S = NULL;
 F = NULL;
 Sub = NULL;
 T = (LString *)malloc(sizeof(LString));
 S = (LString *)malloc(sizeof(LString));
 F = (LString *)malloc(sizeof(LString));
 Sub = (LString *)malloc(sizeof(LString));
 
 InitLString(T);
 StrAssign(T, chars);
 
 StrPrint(*T);
 
 StrCopy(S,*T);
 StrPrint(*S); 
 Concat(F, *T, *S);
 StrPrint(*F); 
 SubString(Sub, *F, 2, 7);
 StrPrint(*Sub);
// printf("%d\n",StrCompare(*T,*Sub));
// printf("%d\n",Index(*F, *Sub, 1));
 StrInsert(F, 2, *Sub);
 StrPrint(*F);
//  StrDelete( F ,2, 7);
// StrPrint(*F);
}