顺序串的基本操作.docx

顺序串的基本操作.docx

《顺序串的基本操作.docx》由会员分享，可在线阅读，更多相关《顺序串的基本操作.docx（16页珍藏版）》请在冰豆网上搜索。

顺序串的基本操作

#include

#include

#defineOK1

#defineERROR0

intMAX_SIZE=50;

typedefstruct{

char*pData;

intlength;//字符串的长度

}SeqString;

//顺序串的初始化

SeqString*InitString（SeqString*L）

{

if（NULL==L）

{

L=（SeqString*）malloc（sizeof（SeqString））;//为串申请空间

if（!

L）

{

printf（"顺序串初始化失败！

\n"）;//申请失败输出的提示语

returnNULL;

}

}

L->pData=（char*）malloc（（MAX_SIZE+1）*sizeof（char））;//为串的元素申请空间

if（!

L->pData）

{

printf（"顺序串初始化失败！

\n"）;

free（L）;//初始化失败释放串的空间

returnNULL;

}

L->pData[0]='\0';//初始化的传为空的

L->length=0;//穿的长度为0

returnL;

}

//顺序串的销毁

intDestroyString（SeqString*L）

{

if（!

L）

{

returnERROR;

}

if（L->pData）

{

free（L->pData）;//逐个释放串的空间

L->pData=NULL;

}

L->length=0;//串的长度为0

returnOK;

}

//串赋值1：

从char*复制,要求des是有效的顺序串，src为有效的字符串指针，即非NULL

intCopyFromChars（SeqString*des,char*src）

{

intk=0;

for（k=0;*（src+k）&&k

{

des->pData[k]=*（src+k）;//把串src逐个复制到des

}

des->pData[k]='\0';//结束串

des->length=k;//串的长度为k

returnOK;

}

//串赋值2：

从SeqString*复制

intCopyFromSeqString（SeqString*des,SeqString*src）

{

intk=0;

for（k=0;k<=src->length;k++）

{

des->pData[k]=src->pData[k];//把串逐个赋给des

}

des->length=src->length;//复制后的串的长度为原串的长度

returnOK;

}

//串连接

intConnectStrings（SeqString*des,SeqString*src）

{

intk=0;

if（des->length+src->length>MAX_SIZE）

{

printf（"两个字符串长度之和大于顺序串的最大长度！

\n"）;

returnERROR;

}

for（k=0;k<=src->length;k++）

{

des->pData[des->length+k]=src->pData[k];//把第二个串复制到第一个串的尾部

}

des->length+=src->length;//新串的长度等于两个串长度想加

returnOK;

}

intReverseString（SeqString*L）

{

intk=0;

chartemp;

if（L->length<=1）

{

returnOK;

}

for（k=0;klength/2;k++）

{

temp=L->pData[k];

L->pData[k]=L->pData[L->length-1-k];

L->pData[L->length-1-k]=temp;//交换对应位置的值

}

returnOK;

}

//输出顺序串中的每个元素

voidPrintString（SeqString*L）

{

if（!

L||!

L->pData）

{

printf（"顺序串不存在!

\n"）;

return;

}

if（0==L->length）

{

printf（"顺序串是空的!

\n"）;

return;

}

printf（"串中的元素有:

\t"）;

printf（"%s\n",L->pData）;//一次输出串中的元素

printf（"\n"）;

}

//置空串

intSetEmpty（SeqString*L）

{

if（!

L->pData）

{

returnERROR;

}

L->pData[0]='\0';//把串置空

L->length=0;//串的长度为1

returnOK;

}

//求串长

intGetStringLength（SeqString*L）

{

if（L->pData）

{

returnL->length;//返回串的长度

}

return-1;//顺序串没有分配内存时,返回-1

}

//按位置查找元素:

i=0表示第一个元素

charGetChar（SeqString*L,inti）

{

if（0>=i||!

L->pData||i>=L->length）

{

printf（"顺序串不存在或是为空串!

\n"）;

exit（EXIT_FAILURE）;

}

returnL->pData[i];//返回第i个位置的长度

}

//查找元素第一个位置,若无返回-1

charGetPosition（SeqString*L,charx）

{

intk=0;

if（!

L->pData）

{

printf（"顺序串不存在!

\n"）;

exit（EXIT_FAILURE）;

}

for（k=0;klength;k++）

{

if（x==L->pData[k]）

returnk;//返回要查找的元素的位置

}

return-1;//表示顺序串中无此元素

}

//判断是否为空:

1为空,0为非空

intIsEmpty（SeqString*L）

{

if（!

L->pData）

{

printf（"顺序串不存在!

\n"）;

exit（EXIT_FAILURE）;

}

returnL->length==0;

}

//求子串

SeqString*Substring（SeqString*L,intindex,intlen）

{

SeqString*temp=NULL;

intk=0;

if（index<0||len<=0||index+len>L->length）

{

printf（"参数不合法！

\n"）;

returnNULL;

}

temp=InitString（temp）;

for（k=0;k

{

temp->pData[k]=L->pData[index+k];//把第i个位置以后的元素赋给新串

}

temp->pData[k]='\0';//结束新串

temp->length=len;//新串的长度为截取的子串的长度

returntemp;

}

//串比较，相等返回0，第1个小于第2个，返回－1，第1个大于第2个，返回1

intStringCompare（SeqString*str1,SeqString*str2）

{

intflag=0;

intminLen;

intk=0;

if（!

str1||!

str2）

{

printf（"某个字符串不存在！

"）;

return-10;//表示不可比较

}

minLen=（str1->length>str2->length?

str2->length:

str1->length）+1;

for（k=0;k

flag;k++）

{

flag=str1->pData[k]-str2->pData[k];//把串1中元素减串2中的元素结果赋给flag

}

if（!

flag）

{

returnflag;

}else

{

returnflag>0?

1:

-1;

}

}

//子串定位:

若substr在str中出现，则返回第1次出现的位置；否则返回－1

intSubstringLocate（SeqString*str,SeqString*substr）

{

intflag=-1,i,j;

if（!

str||!

substr||str->lengthlength）

{

returnflag;

}

for（i=0;ilength-substr->length;i++）//判断两串的长度是否相等

{

for（j=0;jlength;j++）

{

if（str->pData[i+j]-substr->pData[j]）//判断两串的对应元素是否相等

{

break;

}

}

if（j==substr->length）

{

returni;

}

}

return-1;

}

//串插入

intSubstringInsert（SeqString*L,intindex,SeqString*str）

{

intk=0;

SeqString*substr=NULL;//为的是可以串自身插入到自身

if（!

L||!

L->pData||!

str||!

str->pData||index<0

||L->length+str->length>MAX_SIZE）

{

returnERROR;

}

substr=InitString（substr）;//初始化新串

CopyFromSeqString（substr,str）;//把串复制

for（k=L->length;k>=index;k--）

{

L->pData[k+substr->length]=L->pData[k];//先移动L中index起所有后面的元素

}

//把子串插入

for（k=0;klength;k++）

{

L->pData[index+k]=substr->pData[k];

}

L->length+=str->length;//新串的长度是两个串的和

DestroyString（substr）;//销毁串substr

substr=NULL;

returnOK;

}

//子串删除

intSubstringDelete（SeqString*L,intindex,intlen）

{

intk=0;

if（index<0||len<=0||index+len>L->length）

{

printf（"参数不合法\n"）;

returnERROR;

}

for（k=0;k<=L->length-（index+len）;k++）

{

L->pData[index+k]=L->pData[index+len+k];//把要删除的子串前移

}

L->length-=len;//串长度减len

returnOK;

}

//串替换

intSubstringSubstitute（SeqString*L,intindex,SeqString*str）

{

intk=0;

SeqString*substr=NULL;

if（!

L||!

L->pData||!

str||!

str->pData||index<0

||index+str->length>MAX_SIZE）

{

returnERROR;

}

substr=InitString（substr）;//初始化串

CopyFromSeqString（substr,str）;//复制串

for（k=0;k<=substr->length;k++）

{

L->pData[index+k]=substr->pData[k];//把串中的元素

}

L->length=index+str->length;

DestroyString（substr）;

substr=NULL;

returnOK;

}

//比较两个字串是否相等

intIsEqual（SeqString*str1,SeqString*str2）

{

intk=0;

if（!

str1||!

str1->pData||!

str2||!

str2->pData）

{

return0;//若有一个字符串不存在,返回0

}

if（str1->length!

=str2->length）

{

return0;//若长度不相等,返回0

}

while（klength&&!

（str1->pData[k]-str2->pData[k]））

{

k++;//比较相应字符

}

if（k==str2->length）

{

return1;

}else{

return0;

}

}

voidmain（）

{

SeqString*L=NULL,*des=NULL,*subL=NULL;

L=InitString（L）;//初始化顺序串

des=InitString（des）;

subL=InitString（subL）;

printf（"复制串abcd：

"）;

CopyFromChars（des,"abcd"）;

PrintString（des）;

printf（"复制串abc：

"）;

CopyFromChars（L,"abc"）;

PrintString（L）;

printf（"判断两串是否相等:

"）;

printf（"%d\n",IsEqual（L,des））;

printf（"复制串abcdefgh：

"）;

CopyFromChars（L,"abcdefgh"）;

PrintString（L）;//打印顺序串

printf（"截取子串%s\n",*Substring（L,4,2））;

printf（"子串位置:

%d\n",SubstringLocate（L,Substring（L,4,2）））;

SubstringSubstitute（L,3,L）;

PrintString（L）;//打印顺序串

SubstringInsert（L,9,L）;

PrintString（L）;//打印顺序串

SubstringDelete（L,1,2）;

PrintString（L）;//打印顺序串

subL=Substring（L,1,4）;

printf（"比较大小%d\n",StringCompare（subL,L））;

PrintString（subL）;

CopyFromSeqString（des,L）;

PrintString（des）;

printf（"比较大小%d\n",StringCompare（des,L））;

ConnectStrings（des,L）;//顺序的连接

PrintString（des）;

ReverseString（L）;

PrintString（L）;//打印顺序串

printf（"%d\n",GetPosition（L,10））;

printf（"%d\n",GetStringLength（L））;

if（IsEmpty（L））{

printf（"顺序串是空的\n"）;

}else{

printf（"顺序串是非空的\n"）;

}

SetEmpty（L）;//把顺序串置空

PrintString（L）;//打印顺序串

DestroyString（L）;//不要忘了

PrintString（L）;//打印顺序串

DestroyString（des）;//销毁顺序串

PrintString（des）;//打印顺序串

DestroyString（subL）;//销毁顺序串

PrintString（subL）;//打印顺序串

if（!

L）

free（L）;

if（!

des）

free（des）;

}