数据结构——串

1 串

1.1 串的定义

  由零个或多个字符组成的有限序列，串又被称为字符串；标记为：s="a₁,a₂,a₃,...,a_i,...,a_n"(n>=0),其中ai可以使字母、数字、其他字符；

1.2 串的相关概念

  串的长度：串中的字符个数

  空串：不含任何字符的串

  空格串：只包含空格的串

  主串：包含子串的串

  子串：主串中任意个数的连续字符组成有限序列

1.3 串的抽象数据类型

  ADT串：

    data：

      s="a₁,a₂,a₃,...,a_i,...,a_n"(n>=0)

    operation   

InitString(S,str)      //初始化操作，建立串
DestoryString(S)  //销毁串
ClearString(S)    //清空串
StringEmpty(S)  //若串为空，返回true
                        //若串不为空，返回false
Length(str)      //获取指定字符串的长度
CopyString(S,str)  //将字符串str的所有字符复制到字符串S中
CompareString(S,T)   //比较两个字符串的大小
                               //若S<T,返回负数
                               //若S=T,返回0
                              //若S>T,返回整数

2 串的存储结构

2.1 串的存储结构

typedef struct String
{
  char *data;
  int length;
  int maxlength;
}String;

2.2 串的初始化操作

void InitString(String *S,char *str)
{
  int len=Length(str);
  S->data=(char*)malloc((len+1)*sizeof(char));
  S->length=len;
  S->maxlength=len;
  for(int i=0;i<len;i++)
  {
    S->data[i]=str[i];
  }
  S->data[i]='\0';
}

2.3 销毁串

void DestoryString(String *S)
{
  if(S->data==NULL)
    return;
  free(S->data);
  S->data=NULL;
  S->length=0;
  S->maxlength=0;
}

2.4 清空串

void ClearString(String *S)
{
  if(S->data==NULL)
    return;
  S->length=0;
}

2.5 判断串是否为空

bool StringEmpty(String *S)
{
  return S->data != NULL && S->length==0;
}

2.6 获取指定字符串长度

int length(char *str)
{
  int length=0
  while(str[length]!='\0')
  {
    length++;
  }
  return length;
}

int length(String *s)
{
  return s->length;
}

2.7 复制字符串

void CopyString(String *S,char *string)
{
  if(S->data==NULL)
    return;
  int length=length(string);
  if(length>S->maxlength)
  {
    S->data=(char*)realloc(S->data,(length+1)*sizeof(char));
    S->maxlength=length;
  }
  for(i=0;i<length;i++)
    S->data[i]=string[i];
  S->data[length]='\0';
  S->length=length;
}

2.8 字符串比较

int CompareString(String *S1,String *S2)
{
  if(S1->data==NULL && S2->data==NULL)
    return 0;
  if(S1->data==NULL && S2->data!=NULL)
    return -1;
  if(S1->data!=NULL && S2->data==NULL)
    return 1;
  if(S1->length==0)
    return(S2->length==0)?0:1;
  if(S2->length==0)
    return(S1->length==0)?0:1;
  int i=0;
  while(true)
  {
    if(S1->data[i]>S2->data[i])
      return 1;
    else if(S1->data[i]<S2->data[i])
      return -1;
    else if(S1->data[i]=='\0' && S1->data[i]==S2->data[i])
      return 0;
    i++;
  }
}

2.9 截取子串

char *subString(String *S,int pos,int len)
{
  if(S->data==NULL)
    return NULL;
  if(pos<0||pos>=S->length)
    return NULL;
  if(len>S->length-pos)
    return NULL;
  char *result=(char*)malloc((len+1)*sizeof(char));
  for(int i=0;i<len;i++)
    result[i]=S->data[pos+i];
  result[len]='\0';
  return result;
}

2.10 定位子串

int locate(String *S,char* str,int pos)
{
  if(S->data==NULL)
    return -1;
  if(pos<0||pos>=S->length)
    return -1;
  int len=length(str);
  if(len+pos>S->length)
    return -1;
  for(int i=pos;i<S->lenght-len;i++)
  {
    int j;
    for(j=0;j<len;j++)
    {
      if(S->data[i+j]!=str[j])
        break;
    }
    if(j==len)
      return i;
  }
  return -1;
}

2.11 插入子串

Status insert(String *S,int pos,char *str)
{
  if(S->data==NULL)
    return ERROR;
  if(pos<0||pos>=S->length)
    return ERROR;
  int len=length(str);
  if(len+pos>S->length)
    return -1;
  if(S->length+len>S->maxlength)
  {
    S->data=(char*)realloc(S->data,(S->length+len+1)*sizeof(char));
    S->maxlength=S->length+len;
  }
  return SUCCESS;
}

2.12 删除子串

Status delete(String *S,int pos,int len)
{
  if(S->data==NULL)
    return ERROR;
  if(pos<0||pos>=S->length)
    return ERROR;
  if(len+pos>S->length)
    return ERROR;
  for(int i=pos+len;i<S->lenght;i++)
    S->data[i-len]=S->data[i];
  S->length-=len;
  return SUCCESS;
}

2.13 替换子串

Status replaceString(String *S,char *oldstr,char *newstr)
{
  if(S->data==NULL)
    return ERROR;
  int index=locate(S,oldstr,0);
  while(index>=0)
  {
    int oldlen=length(oldstr);
    int newlen=length(newstr);
    delete(S,index,oldlen);
    insert(S,index,newstr);
    index=locate(S,oldstr,index+newlen);
  }
  return SUCCESS;
}