C学习笔记04#数据结构#串

串

1.1 串类型的定义

• 串是由零个或多个字符组成的有限序列，一般记为s = ‘a1a2a3…an’(n>=0)

• 其中，s是串的名，用单引号括起来的字符序列是串的值；ai(1<=i<=n)可以是字母、数字或其它字符；串中字符的数目n称为串的长度。零个字符的串称为空串，它的长度为零。

• 串中任意个连续的字符组成的子序列称为该串的子串。包含子串的串相应地称为主串。通常称字符在序列中的序号为该字符在串中的位置。子串在主串中的位置则以子串的第一个字符在主串中的位置来表示。

• 1.2 串的抽象数据类型定义：

  ADT String{
      数据对象：D={ai|ai∈CharacterSet,i=1,2,...,n,n>=0}
      数据关系：R1={<ai-1,ai>|ai-1}
      基本操作：
          StrAssig(&T,chars)
      初始条件：chars是字符串常量
    操作结果：生成一个其值等于chars的串T
          StrCopy(&T,S)
      初始条件：串S已存在
      操作结果：由串S复制得串T
          StrEmpty(S)
      初始条件：串S存在
      操作结果：若串S为空串，则返回TRUE，否则返回FALSE
       	StrCompare(S,T)
      初始条件：串S和T存在
      操作结果：若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0
          StrLength(S)
      初始条件：串S存在
      操作结果：返回S的元素个数，称为串的长度
          ClearString(&S)
      初始条件：串S存在
      操作结果：将S清为空串
          Concat(&T,S1,S2)
      初始条件：串S1和S2存在
      操作结果：用T返回由S1和S2连接而成的新串
          SubString(&Sub,S,pos,len)
      初始条件：串S已存在，1<=pos<=StrLength(S)且0<=len<=StrLength(S)-pos+1
      操作结果：用Sub返回串S的第pos个字符起长度为len的子串
          Index(S,T,pos)
      初始条件：串S和T存在，T是非空串，1<=pos<=StrLength(S)
      操作结果：若主串S中存在和串T值相同的子串，则返回它在主串S中第pos个字符之后第一次出现的位置；否则函数值为0
          Replace(&S,T,V)
      初始条件：串S，T和V存在，T是非空串
      操作结果：用V替换主串S中出现的所有与T相等的不重叠的子串
          StrInsert(&S,pos,T)
      初始条件：串S和T存在，1<=pos<=StrLength(S)+1
      操作结果：在串S的第pos个字符之前插入串T
          StrDelete(&S,pos,len)
      初始条件：串S存在，1<=pos<=StrLength(S)
      操作结果：从串S中删除第pos个字符起长度为len的子串
          DestroyString(&S)
      初始条件：串S存放
      操作结果：串S被销毁
  }ADT String
  

1.2 串的表示和实现

1.2.1 串的顺序存储表示

• 类似线性表的顺序存储结构，用一组连续的存储单元存储串值的字符序列

  #define MAXSTRLEN 255 //用户可在255以内定义最大串长
  typedef unsigned char SString[MAXSTRLEN + 1]; //o号单元存放串的长度
  

• 串长的定义方法有俩种：

  • 以下标为0的数组分量存放串的实际长度
  • 在串值后面加一个不计入串长的结束标记字符

1.2.2 串的堆分配存储表示

• 这种表示方式，仍是以一组地址连续的存储单元存放串值字符序列，但它们的存储空间是在程序执行过程中动态分配而得

  typedef struct {
  
  	char* ch;
  
  	int length;
  }HString;
  
  //----------------------
  //StrAssign
  Status StrAssign(HString &T,char *chars) {
  	int i;
  	char *c;
  	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))))
  			exit(OVERFLOW);
  		for (int k = 0; k < i; k++) {
  			T.ch[k] = chars[k];
  			T.length = i;
  		}
  	}
  
  	return OK;
  }
  
  //----------------------
  //StrLength
  int StrLength(HString S) {
  	
  	return S.length;
  
  }
  
  //----------------------
  //StrCompare
  int StrCompare(HString S, HString T) {
  
  	for (int 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;
  }
  
  //----------------------
  //ClearString
  Status ClearString(HString &S) {
  
  	if (S.ch) { free(S.ch); S.ch = NULL;}
  	S.length = 0;
  	return OK;
  }
  
  //----------------------
  //Concat
  Status Concat(HString &T, HString S1, HString S2)
  {
  	if (T.ch) { free (T.ch); }
  	if (!(T.ch = (char *)malloc((S1.length + S2.length) * sizeof(char))))
  		exit(OVERFLOW);
  	for (int i = 0; i < S1.length; i++) {
  		T.ch[i] = S1.ch[i];
  	}
  	T.length = S1.length + S2.length;
  	for (int i =S1.length,k =0; i < S2.length; i++,k++) {
  		T.ch[i] = S2.ch[k];
  	}
  	return OK;
  }
  
  //----------------------
  //SubString
  Status SubString(HString &Sub,HString S,int pos,int len) {
  	if (pos<1 || pos>S.length || len<1 || len>S.length - pos + 1)
  		return ERROR;
  	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 = pos - 1,k = 0; k < len; i++, k++) {
  			Sub.ch[k] = S.ch[i];
  		}
  		Sub.length = len;
  	}
  	return OK;
  }
  

1.2.3 串的块链存储表示

• 利用链表存储串值时，存在一个“结点大小”的问题，即每个结点可以存放一个字符，也可以存放多个字符

• 由于串长不一定是结点大小的整数倍，则链表最后一个结点不一定全被串值占满，此时通常补上“#”或其它字符

  #define CHUNKSIZE 80 //可有用户定义块的大小
  typedef struct Chunk{
      char ch[CHUNKSIZE];
      struct Chunk *next;
  }Chunk;
  typedef struct{
      Chunk *head,*tail;
      int curlen;
  }
  

• 串值的存储密度：
  $$存储密度=串值所占的存储尾/实际分配的存储位$$
  存储密度小时，运算处理方便