数据结构-串

不羈115

于 2023-07-07 18:52:29 发布

阅读量82

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/qq_61959524/article/details/131598057

版权

顺序串

类型声明

typedef struct
{
  char data[MaxSize];
  int length;
}SqString;

生成串

void StrAssign(SqString &s,char  cstr[])  //s为引用型参数
{
  int i;
  for(i=0;cstr[i] !='\0';i++)
     s.data[i]=cstr[i];
  s.length=i;     //设置长度
}

销毁串

顺序串是直接采用顺序串本身表示而不是顺序串指针，存储空间由操作系统管理，操作系统分配存储空间并在超过作用域的时候释放。销毁不包含任何操作。

void DestroyStr(SqString &s)

串的复制

void StrCopy(SqString &s,SqString t)
{
  int i;
  for(i=0;i<t.length;i++)  //复制t的所有字符
     s.data[i]=t.data[i];
  s.length=t.length;    //设置串s的长度·
}

判断串相等

bool StrEqual(SqString s,SqString t)
{
  bool same=true;int i;
  if(s.length != t.length)  //长度不相等时返回0
     same=false;
  else
     for(i=0;i<s.length;i++)
        if(s.data[i] != t.data[i])  //有一个对应字符不相同时返回假
        {
           same=false;
           break;
        }
   return same;
}

求串长

int StrLength(SqString s)
{
  return s.length;
}

串的连接

SqString Concat(SqString s,SqString t)
{
  SqString str;  //定义结果串
  int i;
  str.length=s.length+t.length;
  for(i=0;i<s.length;i++)  //将s.data[0..s.length-1]复制到str
  {
   str.data[i]=s.data[i];
  for(i=0;i<t.length;i++)  //将t.data[0..t.length-1]复制到str
  {
   str.data[s.length+i]=t.data[i];
  return str;
}

求子串

SqString SubStr(SqString s,int i,int j)
{
  int k;
  SqString str;   //定义结果串
  str.length=0;    //设置结果串为空串
  if(i<=0 || i>s.length || j<0 || i+j-1>s.length)
    return str;
  for(k=i-1;k<i+j-1;k++)   //将s.data[i..i+j-1]复制到str
    str.data[k-i+1]=s.data[k];
  str.length=j;
  return str;
}

字串的插入

SqString InsStr(SqString s1,int i,SqString s2)
{
  int j;
  SqString str;    //定义结果串
  str.length=0;   //空
  if(i<=0 || i>s1.length+1)  //参数不对
    return str;
  for(j=0;j<i-1;j++)  //将s1.data[0..i-2]复制到str
     str.data[j]=s1.data[j];
  for(j=0;j<s2.length;j++)  //将s2.data[0..s2.length-1]复制到str
     str.dat[i+j-1]=s2.data[j];
  for(j=i-1;j<s1.length;j++)    //将s1.data[i-1...s1.length-1]复制到str
     str.data[s2.length+j]=s1.data[j];
  str.length=s1.length+s2.length;
  return str;
}

字串的删除

SqString DelStr(SqString s,int i,int j)
{
 int k;
 SqString str;
 str.length=0;
 if(i<=0 || i>s.length || i+j>s.length+1)
   return str;
 for(k=0;k<i-1;k++)  //将s.data[0..i-2]复制到str
   str.data[k]=s.data[k];
 for(k=i+j-1;k<s.length;k++)  //将s.data[i+j-1..s.length-1]复制到str
   str.data[k-j]=s.data[k];
 str.length=s.length-j;
 return str;

}

字串的替换

SqString RepStr(SqString s,int i,int j,SqString t)
{
  int k;
  SqString str;
  str.length=0;
  if(i<=0 || i>s.length || i+j-1>s.length)
    return str;
  for(k=0;k<i-1;k++)  //将s.data[0..i-2]复制到str
    str.data[k]=s.data[k];
  for(k=0;k<t.length;k++)  //将t.data[0..t.length-1]复制到str
    str.data[i+k-1]=t.data[k]
  for(k=i+j-1;k<s.length;k++)  //将s.data[i+j-1..s.length-1]复制到str
    str.data[t.length+k-j]=s.data[k];
  str.length=s.length-j+t.length;
  return str;
}

输出串

void DispStr(SqString s)
{
  int i;
  if(s.length>0)
  {
    for(i=0;i<s.length;i++)
      print("%c",s.data[i]);
    printf("\n");
  }
}

链串

声明

typedef struct snode
{
  char data;
  struct snode *next;
}LinkStrNode;

生成串

void StrAssign(LinkStrNode *&s,char cstr[])
{
 int i;
 LinkStrNode *r,*p;
 s=(LinkStrNode *)malloc(sizeof(LinkStrNode));
 r=s;     //r始终指向尾结点
 for(i=0;cstr[i] != '\0';i++)
 {
  p=(LinkStrNode *)malloc(sizeof(LinkStrNode));
  p->data=cstr[i];
  r->next=p;r=p;
 }
 r->next=NULL;
}

销毁串

void DestroyStr(LinkStrNode *&s)
{
 LinkStyNode *pre=s,*p=s->next;   //pre指向p的前驱结点
 while(p!=NULL)
 {free(pre);
  pre=p;
  p=pre->next;
 }
 free(pre);
}

串的复制

void StrCopy(LinkStrNode *&s,LinkStrNode *t)
{
  LinkStrNode*p=t->next,*q,*r;
  s=(LinkStrNode *)malloc(sizeof(LinkStrNode));
  r=s;
  while(p!=NULL)
  {
   q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
   q->data=p->data;  //将p结点复制到q结点
   r->next=q;r=q;   //将q结点到s的尾
   p=p->next;
  }
  r->next=NULL;
}

判断串相等

bool StrEqual(LinkStrNode *s,LinkStrNode *t)
{
  LinkStrNode *p=s->next, *q=t->next;
  while(p!=NULL && q!=NULL && p->data==q->data)
  {
    p=p->next;
    q=q->next;
  }
  if(p==NULL && q==NULL)
   return true;
  else
   return false;
}

求串长

int StrLength(LinkStrNode *s)
{
  int i=0;
  LinkStrNode *p=s->next;
  while(p!=NULL)
  {
   i++;
   p=p->next;
  }
  return i;
}

串的连接

LinkStrNode *Concat(LinkStrNode *s,LinkStrNode *t)
{
  LinkStrNode *str,*p=s->next,*q,*r;
  str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
  r=str;                    //r指向尾
  while(p!=NULL)   //p扫描s中的结点
  {
    q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    q->data=p->data;
    r->next=q;r=q;
    p=p->next;
  }
  p=t->next;
  while(p!=NULL)       p扫描t中的结点
  {
    q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    q->data=p->data;
    r->next=q;r=q;
    p=p->next;
  }
  r->next=NULL;
  return str;
}

求子串

LinkStrNode *SubStr(LinkStrNode *s,int i,int j)
{
  int k;
  LinkStrNode *str,*p=s->next,*q,*r;
  str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
  str->next=NULL;    //置为空
  r=str;
  if(i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s))
   return str;
  for(k=1;k<i;k++)  //让p指向串s的第i个数据结点
   p=p->next;
  for(k=1;k<j;k++)   //将s的从第i个结点开始的j个结点复制个给str
   {
     q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
     q->data=p->data;
     r->next=q;r=q;
     p=p->next;
   }
  r->next=NULL;
  return str;
}

子串的插入

LinkStrNode *InsStr(LinkStrNode *s,int i,LinkStrNode *t)
{
  int k;
  LinkStrNode *str,*p=s->next,*p1=t->next,*q,*r;
  str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
  str->next=NULL;
  r=str;
  if(i<0 || i>StrLength(s)+1)
    return  str;
  for(k=1;k<i;k++)  //将s的前i个结点复制给ste
  {
    q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    q->data=p->data;
    r->next=q;r=q;
    p=p->next;
  }
  while(p1 != NULL)  //将所有结点复制给str
  {
    q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    q->data=p->data;
    r->next=q;r=q;
    p1=p1->next;
  }
  while(p!=NULL)   //将p结点及其后的结点复制给str
  {
    q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    q->data=p->data;
    r->next=q;r=q;
    p=p->next;
  }
  r->next=NULL;
  return str;
}

子串的删除

LinkStrNode *DelStr(LinkStrNode *s,int i,int j)
{
   int k;
   LinkStrNode *str,*p=s->next,*q,*r;
   str=q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
   str->next=NULL;
   r=str;
   if(i<0 || i>StrLength(s) || j<0 || i+j-1 > StrLength(s))
    return str;
   for(k=1;k<i;k++)  //将s的前i-1个结点复制给str
   {
     q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
     q->data=p->data;
     r->next=q;r=q;
     p=p->next;
   }
   for(k=0;k<j;k++)  //让P沿next跳j个结点
   {
     p=p->next;
   while(p!=NULL)  //将p结点及其后的结点复制给str
   {
      q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
      q->data=p->data;
      r->next=q;r=q;
      p=p->next;
    }
   r->next=NULL;
   return str;
}

子串的替换

LinkStrNode *RepStr(LinkStrNode *s,int i,int j,LinkStrNode *t)
{
   int k;
   LinkStrNode *str,*p=s->next,*p1=t->next,*q,*r;
   str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
   str->next=NULL;
   r=str;
   if(i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s))
     return str;
   for(k=0,k<i-1;k++)  //将s的前i-1个数据结点复制到str
   {
    q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    q->data=p->data;  q->next=NULL;
    r->next=q;r=q;
    p=p->next;
   }
   for(k=0;k<j;k++)
   {
    p=p->next;
   }
   while(p!=NULL)     //将t的所有数据结点复制到str
   {
    q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    q->data=p->data; q->next=NULL;
    r->next=q;r=q;
    p=p->next;
   }
   while(p!=NULL)    //将p所指结点及其后的结点复制到str
  {
    q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    q->data=p->data; q->next=NULL;
    r->next=q;r=q;
    p=p->next;
   }
   r->next=NULL;
   return str;
}

输出串

void DispStr(LinkStrNode *s)
{
 LinkStrNode *p=s->next;   //p指向首结点
 while(p!=NULL)
 {
   printf("%c",p->data);
   p=p->next;
 }
 printf("\n")
}

不羈115

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
数据结构-串

顺序串是直接采用顺序串本身表示而不是顺序串指针，存储空间由操作系统管理，操作系统分配存储空间并在超过作用域的时候释放。销毁不包含任何操作。
复制链接

扫一扫