数据结构.docx

数据结构.docx

《数据结构.docx》由会员分享，可在线阅读，更多相关《数据结构.docx（30页珍藏版）》请在冰豆网上搜索。

数据结构

广东技术师范学院实验报告

实验地点：

计算机网络中心3

实验日期：

11-11-1

是否预习

是

操作情况

正常

数据结果

正确

实验（6）项目名称：

实现顺序串各种基本运算

1.实验项目名称实现顺序串各种基本运算

2.功能项目组成与要求

编写第一个程序algo4-1,cpp，实现顺序串的各种基本运算，并在此基础上设计一个主程序完成如下功能：

（1）建立串s=”abcdefghefghijklmn”和串s1=”xyz”。

（2）输出串s。

（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个字符而产生串s。

（11）输出串s3。

（12）将串s1和串s2连接起来而产生串s4.

（13）输出串s4。

3.程序中包含函数：

顺序串（除主函数外）

StrAssign（SqString&str,charcstr[]）:

由串常量cstr创建串str

StrCopy（SqString&s,SqStringt）:

将串t复制到串S

StrEqual（SqStrings,SqStringt）:

判断两个串S和t是否相同

Strlength（SqStrings）:

求串S的长度

Concat（SqStrings,SqStringt）:

将串t连接到串s之后产生新串

SubStr（SqStrings,inti,intj）:

由串s的第i个字符开始的j个字符产生新串

InsStr（SqStrings1,inti,SqStrings2）:

由串s2插入到串s1的第i个位置处

DelStr（SqStrings,inti,intj）:

删除串s的第i个字符开始的j个字符产生新串

RepStr（SqStrings,inti,intj,SqStringt）:

将串s的第i个字符开始的j个字符替换成串t产生新串

DispStr（SqStrings）:

输出串s的所有元素

链串（除主函数外）

StrAssign（LiString*&s,chart[]）:

由串常量cstr创建串str

StrCopy（LiString*&s,LiString*t）:

将串t复制到串S

StrEqual（LiString*s,LiString*t）:

判断两个串S和t是否相同

Strlength（LiString*s）:

求串S的长度

Concat（LiString*s,LiString*t）:

将串t连接到串s之后产生新串

SubStr（LiString*s,inti,intj）:

由串s的第i个字符开始的j个字符产生新串

InsStr（LiString*s1,inti,LiString*s2）:

由串s2插入到串s1的第i个位置处

DelStr（LiString*s,inti,intj）:

删除串s的第i个字符开始的j个字符产生

RepStr（LiString*s,inti,intj,LiString*t）:

将串s的第i个字符开始的j个字符替换成串t产生新串

DispStr（LiString*str）:

输出串s的所有元素

程序代码清单…

顺序串的源代码：

//文件名:

aglo4-1.cpp

#include

#defineMaxSize100//最多的字符个数

typedefstruct

{

chardata[MaxSize];//定义可容纳MaxSize个字符的空间

intlength;//标记当前实际串长

}SqString;

voidStrAssign（SqString&str,charcstr[]）//由串常量cstr创建串str

{

inti;

for（i=0;cstr[i]!

='\0';i++）

str.data[i]=cstr[i];

str.length=i;

}

voidStrCopy（SqString&s,SqStringt）//将串t复制到串S

{

inti;

for（i=0;i

s.data[i]=t.data[i];

s.length=t.length;

}

intStrEqual（SqStrings,SqStringt）//判断两个串S和t是否相同

{

intsame=1,i;

if（s.length!

=t.length）//长度不相等时返回0

same=0;

else

{

for（i=0;i

if（s.data[i]!

=t.data[i]）//有一个对应字符不相同时返回0

same;

}

returnsame;

}

intStrlength（SqStrings）//求串S的长度

{

returns.length;

}

SqStringConcat（SqStrings,SqStringt）//将串t连接到串s之后产生新串

{

SqStringstr;

inti;

str.length=s.length+t.length;

for（i=0;i

str.data[i]=s.data[i];

for（i=0;i

str.data[s.length+i]=t.data[i];

returnstr;

}

SqStringSubStr（SqStrings,inti,intj）//由串s的第i个字符开始的j个字符产生新串

{

SqStringstr;

intk;

str.length=0;

if（i<=0||i>s.length||j<0||i+j-1>s.length）

{

printf（"参数不正确\n"）;//参数不正确时返回空串

returnstr;

}

for（k=i-1;k

str.data[k-i+1]=s.data[k];

str.length=j;

returnstr;

}

SqStringInsStr（SqStrings1,inti,SqStrings2）//由串s2插入到串s1的第i个位置处

{

intj;

SqStringstr;

str.length=0;

if（i<0||i>s1.length+1）

{

printf（"参数不正确\n"）;//参数不正确时返回空串

returns1;

}

for（j=0;j

str.data[j]=s1.data[j];

for（j=0;j

str.data[i+j-1]=s2.data[j];

for（j=i-1;j

str.data[s2.length+j]=s1.data[j];

str.length=s1.length+s2.length;

returnstr;

}

SqStringDelStr（SqStrings,inti,intj）//删除串s的第i个字符开始的j个字符产生新串

{

intk;

SqStringstr;

str.length=0;

if（i<=0||i>s.length||i+j>s.length+1）

{

printf（"参数不正确\n"）;//参数不正确时返回空串

returnstr;

}

for（k=0;k

str.data[k]=s.data[k];

for（k=i+j-1;k

str.data[k-j]=s.data[k];

str.length=s.length-j;

returnstr;

}

SqStringRepStr（SqStrings,inti,intj,SqStringt）//将串s的第i个字符开始的j个字符替换成串t产生新串

{

intk;

SqStringstr;

str.length=0;

if（i<=0||i>s.length||i+j-1>s.length）//参数不正确时返回空串

{

printf（"参数不正确\n"）;

returnstr;

}

for（k=0;k

str.data[k]=s.data[k];

for（k=0;k

str.data[i+k-1]=t.data[k];

for（k=i+j-1;k

str.data[t.length+k-j]=s.data[k];

str.length=s.length-j+t.length;

returnstr;

}

voidDispStr（SqStrings）//输出串s的所有元素

{

inti;

if（s.length>0）

{

for（i=0;i

printf（"%c",s.data[i]）;

printf（"\n"）;

}

}

//文件名:

exp4-1.cpp

#include

#defineMaxSize100

typedefstruct

{

chardata[MaxSize];//定义可容纳MaxSize个字符的空间

intlength;//标记当前实际串长

}SqString;

externvoidStrAssign（SqString&str,charcstr[]）;

externvoidStrCopy（SqString&s,SqStringt）;

externintStrEqual（SqStrings,SqStringt）;

externintStrlength（SqStrings）;

externSqStringConcat（SqStrings,SqStringt）;

externSqStringSubStr（SqStrings,inti,intj）;

externSqStringInsStr（SqStrings1,inti,SqStrings2）;

externSqStringDelStr（SqStrings,inti,intj）;

externSqStringRepStr（SqStrings,inti,intj,SqStringt）;

externvoidDispStr（SqStringstr）;

voidmain（）

{

SqStrings,s1,s2,s3,s4;

printf（"

（1）建立串s和串s1\n"）;

StrAssign（s,"abcdefghefghijklmn"）;

StrAssign（s1,"xyz"）;

printf（"

（2）输出串s:

"）;

DispStr（s）;

printf（"（3）串s的长度:

%d\n",Strlength（s））;

printf（"（4）由串s的第9个字符位置插入串s1而产生串s2\n"）;

s2=InsStr（s,9,s1）;

printf（"（5）输出串s2:

"）;

DispStr（s2）;

printf（"（6）删除串s的第2个字符开始的5个字符产生新串s2\n"）;

s2=DelStr（s,2,3）;

printf（"（7）输出串s2:

"）;

DispStr（s2）;

printf（"（8）将串s的第2个字符开始的5个字符替换成s1产生新串s2\n"）;

s2=RepStr（s,2,5,s1）;

printf（"（9）输出串s2:

"）;

DispStr（s2）;

printf（"（10）提取串s的第2个字符开始的10个字符产生新串s3\n"）;

s3=SubStr（s,2,10）;

printf（"（11）输出串s3:

"）;

DispStr（s3）;

printf（"（12）将串s1连接到串s2之后产生新串s4\n"）;

s4=Concat（s1,s2）;

printf（"（13）输出串s4:

"）;

DispStr（s4）;

}

链串的源代码：

//文件名:

aglo4-2.cpp

#include

#include

typedefstructsnode

{

chardata;

structsnode*next;

}LiString;

voidStrAssign（LiString*&s,chart[]）

{

inti;

LiString*r,*p;

s=（LiString*）malloc（sizeof（LiString））;

s->next=NULL;

r=s;

for（i=0;t[i]!

='\0';i++）

{

p=（LiString*）malloc（sizeof（LiString））;

p->data=t[i];

p->next=NULL;

r->next=p;

r=p;

}

}

voidStrCopy（LiString*&s,LiString*t）

{

LiString*r,*p=t->next,*q;

s=（LiString*）malloc（sizeof（LiString））;

s->next=NULL;

r=s;

while（p!

=NULL）//将t的所有结点复制到s

{

q=（LiString*）malloc（sizeof（LiString））;

q->data=p->data;

q->next=NULL;

r->next=p;

r=p;

p=p->next;

}

}

intStrEqual（LiString*s,LiString*t）

{

LiString*p=t->next,*q=t->next;

while（p!

=NULL&&q!

=NULL&&p->data==q->data）

{

p=p->next;

q=q->next;

}

if（p==NULL&&q==NULL）

return1;

else

return0;

}

intStrlength（LiString*s）

inti=0;

LiString*p=s->next;

while（p!

=NULL）

{

i++;

p=p->next;

}

returni;

}

LiString*Concat（LiString*s,LiString*t）

LiString*r,*str,*p=s->next,*q;

str=（LiString*）malloc（sizeof（LiString））;

s->next=NULL;

r=str;

while（p!

=NULL）//将t的所有结点复制到str

{

q=（LiString*）malloc（sizeof（LiString））;

q->data=p->data;

q->next=NULL;

r->next=p;

r=p;

p=p->next;

}

p=t->next;

while（p!

=NULL）//将t的所有结点复制到str

{

q=（LiString*）malloc（sizeof（LiString））;

q->data=p->data;

q->next=NULL;

r->next=q;

r=q;

p=p->next;

}

returnstr;

}

LiString*SubStr（LiString*s,inti,intj）

{

LiString*str,*p=s->next,*q,*r;

intk;

str=（LiString*）malloc（sizeof（LiString））;

str->next=NULL;

r=str;

if（i<=0||i>Strlength（s）||j<0||i+j-1>Strlength（s））

{

printf（"参数不正确\n"）;//参数不正确时返回空串

returnstr;

}

for（k=0;k

p=p->next;

for（k=1;k<=j;k++）//将s的第i个结点开始的j个结点复制到str

{

q=（LiString*）malloc（sizeof（LiString））;

q->data=p->data;

q->next=NULL;

r->next=q;

r=q;

p=p->next;

}

returnstr;

}

LiString*InsStr（LiString*s,inti,LiString*t）

{

intk;

LiString*str,*p=s->next,*p1=t->next,*q,*r;

str=（LiString*）malloc（sizeof（LiString））;

str->next=NULL;

r=str;

if（i<=0||i>Strlength（s）+1）

{

printf（"参数不正确\n"）;//参数不正确时返回空串

returnstr;

}

for（k=0;k

{

q=（LiString*）malloc（sizeof（LiString））;

q->data=p->data;

q->next=NULL;

r->next=q;

r=q;

p=p->next;

}

while（p1!

=NULL）//将t的所有结点复制到str

{

q=（LiString*）malloc（sizeof（LiString））;

q->data=p1->data;

q->next=NULL;

r->next=q;

r=q;

p1=p1->next;

}

while（p!

=NULL）//将*p及其后的结点复制到str

{

q=（LiString*）malloc（sizeof（LiString））;

q->data=p->data;

q->next=NULL;

r->next=q;

r=q;

p=p->next;

}

returnstr;

}

LiString*DelStr（LiString*s,inti,intj）

{

intk;

LiString*str,*p=s->next,*q,*r;

str=（LiString*）malloc（sizeof（LiString））;

str->next=NULL;

r=str;

if（i<=0||i>Strlength（s）||j<0||i+j-1>Strlength（s））

{

printf（"参数不正确\n"）;//参数不正确时返回空串

returnstr;

}

for（k=0;k

{

q=（LiString*）malloc（sizeof（LiString））;

q->data=p->data;

q->next=NULL;

r->next=q;

r=q;

p=p->next;

}

for（k=0;k

p=p->next;

while（p!

=NULL）//将*p及其后的结点复制到str

{

q=（LiString*）malloc（sizeof（LiString））;

q->data=p->data;

q->next=NULL;

r->next=q;

r=q;

p=p->next;

}

returnstr;

}

LiString*RepStr（LiString*s,inti,intj,LiString*t）

{

intk;

LiString*str,*p=s->next,*p1=t->next,*q,*r;

str=（LiString*）malloc（sizeof（LiString））;

str->next=NULL;

r=str;

if（i<=0||i>Strlength（s）||j<0||i+j-1>Strlength（s））

{

printf（"参数不正确\n"）;//参数不正确时返回空串

returnstr;

}

for（k=0;k

{

q=（LiString*）malloc（sizeof（LiString））;

q->data=p->data;

q->next=NULL;

r->next=q;

r=q;

p=p->next;

}

for（k=0;k

p=p->next;