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

变强不秃

于 2016-10-21 10:47:24 发布

阅读量366

点赞数

本文链接：https://blog.csdn.net/zangxinxiao/article/details/52880812

版权

/* 
 
copyright （t） 2016，烟台大学计算机学院 
 
*All rights reserved. 
 
*文件名称：1.cpp 
 
*作者：臧新晓
 
*完成日期：2016年10月21日 
 
*版本号：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 
 
*输入描述：无 
 
*程序输出：完成测试后的运行结果 
 
*/

//string.h

#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);                              //输出串

//string.cpp

#include "string.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

#include <stdio.h>  
#include "string.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;  
}