第八周项目2-建立链串的算法库

最新推荐文章于 2021-11-08 22:31:39 发布

YangCJ_

最新推荐文章于 2021-11-08 22:31:39 发布

阅读量253

点赞数 1

本文链接：https://blog.csdn.net/YangCJ_/article/details/53088732

版权

 
  /* 
  
 copyright （t） 2016，烟台大学计算机学院 
  
 *All rights reserved. 
  
 *文件名称：1.cpp 
  
 *作者：车金阳 
  
 *完成日期：2016年11月8日 
  
 *版本号：v1.0 
  
 *问题描述：定义链串的存储结构，实现其基本运算，并完成测试。 
  
 要求： 
 　　1、头文件listring.h中定义数据结构并声明用于完成基本运算的函数。对应基本运算的函数包括： 
         void StrAssign(LiString &s,char cstr[]);              //字符串常量cstr赋给串s 
         void StrCopy(LiString &s,LiString t);                 //串t复制给串s 
         bool StrEqual(LiString s,LiString t);                 //判串相等 
         int StrLength(LiString s);                            //求串长 
         SqString Concat(LiString s,LiString t);               //串连接 
         SqString SubStr(LiString s,int i,int j);              //求子串 
         SqString InsStr(LiString s1,int i,LiString s2);       //串插入 
         SqString DelStr(LiString s,int i,int j);              //串删去 
         SqString RepStr(LiString s,int i,int j,LiString t);   //串替换 
         void DispStr(SqString s);                             //输出串 
     2、在listring.cpp中实现这些函数 
     3、在main函数中完成测试，包括如下内容： 
     (1)建立串s:abcdefghijklmn和串s1:123 
     (2)输出串s和s1 
     (3)输出串s的长度 
     (4)在串s的第9个字符位置插入串s1而产生串s2 
     (5)输出串s2 
     (6)删除串s第2个字符开始的5个字符而产生串s2 
     (7)输出串s2 
     (8)将串s第2个字符开始的5个字符替换成串s1而产生串s2 
     (9)输出串s2 
     (10)提取串s的第2个字符开始的10个字符而产生串s3 
     (11)输出串s3 
     (12)将串s1和串s2连接起来而产生串s4 
     (13)输出串s4 
  
 *输入描述：无 
  
 *程序输出：完成测试后的运行结果 
  
 */  
 

listring.h：

[cpp]view plaincopy 
   
 #include <stdio.h>  
 #include <malloc.h>  
 typedef struct snode                                    //定义链串节点类型  
 {  
     char data;  
     struct snode *next;  
 } LiString;  
 void StrAssign(LiString *&s,char cstr[]);               //字符串常量cstr赋给串s  
 void StrCopy(LiString *&s,LiString *t);                 //串t复制给串s  
 bool StrEqual(LiString *s,LiString *t);                 //判串相等  
 int StrLength(LiString *s);                             //求串长  
 LiString *Concat(LiString *s,LiString *t);              //串连接  
 LiString *SubStr(LiString *s,int i,int j);              //求子串  
 LiString *InsStr(LiString *s,int i,LiString *t);        //串插入  
 LiString *DelStr(LiString *s,int i,int j) ;             //串删去  
 LiString *RepStr(LiString *s,int i,int j,LiString *t);  //串替换  
 void DispStr(LiString *s);                              //输出串  

listring.cpp：

[cpp]view plaincopy 
   
 #include "listring.h"  
 void StrAssign(LiString *&s,char cstr[])                   //字符串常量cstr赋给串s  
 {  
     //尾插法建立链串s  
     int i;  
     LiString *r,*p;                                        //*r为尾指针  
     s=(LiString *)malloc(sizeof(LiString));                //分配字符串s的空间  
     r=s;  
     for(i=0;cstr[i]!='\0';i++)  
     {  
         p=(LiString *)malloc(sizeof(LiString));            //分配存放字符节点的空间  
         p->data=cstr[i];  
         r->next=p;  
         r=p;  
     }  
     r->next=NULL;  
 }  
 void StrCopy(LiString *&s,LiString *t)                     //串t复制给串s  
 {  
     //尾插法建立链串s  
     LiString *p=t->next,*q,*r;  
     s=(LiString *)malloc(sizeof(LiString));  
     r=s;  
     while(p!=NULL)  
     {  
         q=(LiString *)malloc(sizeof(LiString));  
         q->data=p->data;  
         r->next=q;  
         r=q;  
         p=p->next;  
     }  
     r->next=NULL;  
 }  
 bool StrEqual(LiString *s,LiString *t)                    //判串相等  
 {  
     LiString *p=s->next,*q=t->next;  
     while(p!=NULL && q!=NULL && p->data==q->data)         //p.q两指针相伴而随  
     {  
         p=p->next;  
         q=q->next;  
     }  
     if(p==NULL && q==NULL)                                //跳出循环时两串所有data均相同且长度相同，返回真，否则返回假  
         return true;  
     else  
         return false;  
 }  
 int StrLength(LiString *s)                                //求串长  
 {  
     LiString *p=s->next;  
     int len=0;  
     while(p!=NULL)  
     {  
         len++;  
         p=p->next;  
     }  
     return len;  
 }  
 LiString *Concat(LiString *s,LiString *t)                  //串连接  
 {  
     LiString *str,*p=s->next,*p1=t->next,*q,*r;  
     str=(LiString *)malloc(sizeof(LiString));             //构造只有头节点的新串  
     r=str;  
     //尾插法插入（复制）节点  
     while(p!=NULL)                                        //串s复制到新串中  
     {  
         q=(LiString *)malloc(sizeof(LiString));  
         q->data=p->data;  
         r->next=q;  
         r=q;  
         p=p->next;  
     }  
     while(p1!=NULL)                                        //串t复制到新串中  
     {  
         q=(LiString *)malloc(sizeof(LiString));  
         q->data=p1->data;  
         r->next=q;  
         r=q;  
         p1=p1->next;  
     }  
     r->next=NULL;  
     return str;  
 }  
 LiString *SubStr(LiString *s,int i,int j)                  //求子串  
 {  
     int k;  
     LiString *str,*p=s->next,*q,*r;  
     str=(LiString *)malloc(sizeof(LiString));             //构造空的新串  
     str->next=NULL;  
     r=str;                                                //r指向新串（新建链表）的尾节点  
     if(i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s))  
         return str;                                       //参数不正确时返回空串  
     for(k=0;k<i-1;k++)                                    //寻找子串位置，循环跳出后p指向s的第i个节点  
         p=p->next;  
     for(k=1;k<=j;k++)  
     {  
         q=(LiString *)malloc(sizeof(LiString));  
         q->data=p->data;  
         r->next=q;  
         r=q;  
         p=p->next;  
     }  
     r->next=NULL;  
     return str;  
 }  
 LiString *InsStr(LiString *s,int i,LiString *t)            //串插入  
 {  
     int k;  
     LiString *str,*p=s->next,*p1=t->next,*q,*r;  
     str=(LiString *)malloc(sizeof(LiString));             //构造空的新串  
     str->next=NULL;  
     r=str;                                                //r指向新串（新建链表）的尾节点  
     if(i<=0 || i>StrLength(s)+1)  
         return str;                                       //参数不正确时返回空串  
     for(k=1;k<i;k++)                                      //s的前i个节点复制到str  
     {  
         q=(LiString *)malloc(sizeof(LiString));  
         q->data=p->data;  
         r->next=q;  
         r=q;  
         p=p->next;                                        //跳出循环前这一步记录复制*p指向的节点  
     }  
     while(p1!=NULL)                                       //串t复制到str  
     {  
         q=(LiString *)malloc(sizeof(LiString));  
         q->data=p1->data;  
         r->next=q;  
         r=q;  
         p1=p1->next;  
     }  
     while(p!=NULL)                                        //*p及其后的节点复制到str  
     {  
         q=(LiString *)malloc(sizeof(LiString));  
         q->data=p->data;  
         r->next=q;  
         r=q;  
         p=p->next;  
     }  
     r->next=NULL;  
     return str;  
 }  
 LiString *DelStr(LiString *s,int i,int j)                  //串删去  
 {  
     int k;  
     LiString *str,*p=s->next,*q,*r;  
     str=(LiString *)malloc(sizeof(LiString));             //构造空的新串  
     str->next=NULL;  
     r=str;                                                //r指向新串（新建链表）的尾节点  
     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=(LiString *)malloc(sizeof(LiString));  
         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=(LiString *)malloc(sizeof(LiString));  
         q->data=p->data;  
         r->next=q;  
         r=q;  
         p=p->next;  
     }  
     r->next=NULL;  
     return str;  
 }  
 LiString *RepStr(LiString *s,int i,int j,LiString *t)      //串替换  
 {  
     int k;  
     LiString *str,*p=s->next,*p1=t->next,*q,*r;  
     str=(LiString *)malloc(sizeof(LiString));             //构造空的新串  
     str->next=NULL;  
     r=str;                                                //r指向新串（新建链表）的尾节点  
     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=(LiString *)malloc(sizeof(LiString));  
         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(p1!=NULL)                                       //串t复制到str  
     {  
         q=(LiString *)malloc(sizeof(LiString));  
         q->data=p1->data;  
         r->next=q;  
         r=q;  
         p1=p1->next;  
     }  
     while(p!=NULL)                                        //*p及其后的节点复制到str  
     {  
         q=(LiString *)malloc(sizeof(LiString));  
         q->data=p->data;  
         r->next=q;  
         r=q;  
         p=p->next;  
     }  
     r->next=NULL;  
     return str;  
 }  
 void DispStr(LiString *s)                                 //输出串  
 {  
     LiString *p=s->next;  
     while(p!=NULL)  
     {  
         printf("%c",p->data);  
         p=p->next;  
     }  
     printf("\n");  
 }  

main.cpp：

[cpp]view plaincopy 
   
 #include <stdio.h>  
 #include "listring.h"  
 int main()  
 {  
     LiString *s,*s1,*s2,*s3,*s4;  
     char objects[]={"abcdefghijklmn"},objects1[]={"123"};   //s.s1作为目标串  
     StrAssign(s,objects);  
     StrAssign(s1,objects1);                                 //建立串s:abcdefghijklmn和串s1:123  
   
     printf("建立的串s为：");                                //输出串s和s1  
     DispStr(s);  
     printf("建立的串s1为：");  
     DispStr(s1);  
     printf("\n");  
   
     printf("串s的长度为：%d\n\n",StrLength(s));             //输出串s的长度  
   
     s2=InsStr(s,9,s1);                                      //在串s的第9个字符位置插入串s1而产生串s2  
     printf("插入操作后串s2为：");  
     DispStr(s2);                                            //输出串s2  
     printf("\n");  
   
     s2=DelStr(s,2,5);                                       //删除串s第2个字符开始的5个字符而产生串s2  
     printf("删除操作后串s2为：");  
     DispStr(s2);                                            //输出串s2  
     printf("\n");  
   
     s2=RepStr(s,2,5,s1);                                    //将串s第2个字符开始的5个字符替换成串s1而产生串s2  
     printf("替换操作后串s2为：");  
     DispStr(s2);                                            //输出串s2  
     printf("\n");  
   
     s3=SubStr(s,2,10);                                      //提取串s的第2个字符开始的10个字符而产生串s3  
     printf("提取操作后串s3为：");  
     DispStr(s3);  
     printf("\n");  
   
     s4=Concat(s1,s2);                                       //将串s1和串s2连接起来而产生串s4  
     printf("连接操作后串s4为：");  
     DispStr(s4);  
   
     return 0;  
 }  