顺序串的基本操作

#include

#include

#define OK 1

#define ERROR 0

int MAX_SIZE = 50 ;

typedef struct {

char* pData;

int length; // 字符串的长度

}SeqString;

// 顺序串的初始化

SeqString* InitString(SeqString *L)

{

if (NULL==L)

{

L=(SeqString*)malloc(sizeof(SeqString)); //为串申请空间

if(!L)

{

printf("顺序串初始化失败！\n"); //申请失败输出的提示语

return NULL;

}

}

L->pData=(char*)malloc((MAX_SIZE+1)*sizeof(char)); //为串的元素申请空间if(!L->pData)

{

printf("顺序串初始化失败！\n");

free(L); //初始化失败释放串的空间

return NULL;

}

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

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

return L;

}

// 顺序串的销毁

int DestroyString(SeqString *L)

{

if(!L)

{

return ERROR;

}

if(L->pData)

{

free(L->pData); //逐个释放串的空间

L->pData=NULL;

}

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

return OK;

}

// 串赋值1：从char*复制, 要求des是有效的顺序串，src为有效的字符串指针，即非NULL int CopyFromChars(SeqString *des, char *src)

{

int k=0;

for (k=0; *(src+k) && k

{

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

}

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

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

return OK;

}

// 串赋值2：从SeqString* 复制

int CopyFromSeqString(SeqString *des, SeqString *src)

{

int k=0;

for (k=0; k<=src->length; k++)

{

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

}

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

return OK;

}

// 串连接

int ConnectStrings(SeqString *des, SeqString *src)

{

int k=0;

if (des->length + src->length > MAX_SIZE)

{

printf("两个字符串长度之和大于顺序串的最大长度！\n");

return ERROR;

}

for (k=0; k<=src->length; k++)

{

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

}

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

return OK;

}

int ReverseString(SeqString *L)

{

int k=0;

char temp;

if (L->length<=1)

{

return OK;

}

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; //交换对应位置的值}

return OK;

}

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

void PrintString(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");

}

// 置空串

int SetEmpty(SeqString *L)

{

if(!L->pData)

{

return ERROR;

}

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

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

return OK;

}

// 求串长

int GetStringLength(SeqString *L)

{

if(L->pData)

{

return L->length; //返回串的长度

}

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

// 按位置查找元素: i=0表示第一个元素

char GetChar(SeqString *L, int i)

{

if(0>=i || !L->pData || i>=L->length)

{

printf("顺序串不存在或是为空串!\n");

exit(EXIT_FAILURE);

}

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

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

char GetPosition(SeqString *L,char x)

{

int k=0;

if(!L->pData)

{

printf("顺序串不存在!\n");

exit(EXIT_FAILURE);

}

for(k=0;klength;k++)

{

if (x==L->pData[k])

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

}

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

}

// 判断是否为空: 1为空, 0为非空

int IsEmpty(SeqString *L)

{

if(!L->pData)

{

printf("顺序串不存在!\n");

exit(EXIT_FAILURE);

}

return L->length==0;

}

// 求子串

SeqString* Substring(SeqString* L, int index, int len)

{

SeqString* temp=NULL;

int k=0;

if(index<0 || len<=0 || index+len>L->length)

{

printf("参数不合法！\n");

return NULL;

}

temp=InitString(temp);

for(k=0; k

{

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

}

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

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

return temp;

}

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

int StringCompare(SeqString *str1, SeqString *str2)

{

int flag=0;

int minLen;

int k=0;

if(!str1 || !str2)

{

printf("某个字符串不存在！");

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

}

minLen=(str1->length > str2->length ? str2->length : str1->length)+1;

for (k=0; k

{

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

if(!flag)

{

return flag;

}else

{

return flag>0 ? 1:-1;

}

}

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

int SubstringLocate(SeqString *str, SeqString* substr)

{

int flag=-1, i, j;

if(!str || !substr || str->lengthlength)

{

return flag;

}

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)

{

return i;

}

}

return -1;

}

// 串插入

int SubstringInsert(SeqString* L, int index, SeqString* str)

{

int k=0;

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

if(!L || !L->pData || !str || !str->pData || index<0

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

{

return ERROR;

}

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;

return OK;

}

// 子串删除

int SubstringDelete(SeqString* L, int index,int len)

{

int k=0;

if(index<0 || len<=0 || index+len>L->length)

{

printf("参数不合法\n");

return ERROR;

for(k=0;k<=L->length-(index+len); k++)

{

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

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

return OK;

}

// 串替换

int SubstringSubstitute(SeqString*L, int index, SeqString* str)

{

int k=0;

SeqString* substr=NULL;

if(!L || !L->pData || !str || !str->pData || index<0

|| index + str->length>MAX_SIZE)

{

return ERROR;

}

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;

return OK;

}

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

int IsEqual(SeqString* str1, SeqString* str2)

{

int k=0;

if(!str1 || !str1->pData || !str2 || !str2->pData)

{

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

}

if (str1->length != str2->length)

{

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

while (klength && !(str1->pData[k]-str2->pData[k]))

{

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

}

if (k==str2->length)

{

return 1;

}else{

return 0;

}

}

void main()

{

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);

}