重学数据结构：串的基本操作（C语言）

串的结构

#include "stdafx.h"
#include "stdlib.h"
#include "string.h"
#define MaxSize 50
#define bool int
#define true 1
#define false 0;


typedef struct
{
    char *data;
	int length;
}String;

初始化操作

void InitString(String *S)
{
   S->data=(char *)malloc(sizeof(char));
   S->length=0;
   for(int i=0;i<MaxSize;i++)
	   S->data[i]='0';
}

赋值操作

StrAssign(&T,chars)：赋值操作。把串T赋值为chars。

bool StrAssign(String *S,char *t)
{
	int len=strlen(t);
    if(S==NULL||len==0)return false;
    
	for(int i=0;i<len;i++)
	    S->data[i]=t[i];
	S->length=len;
	return true;
}

复制操作

StrCopy(&T,S)：复制操作。由串S复制得到串T。

bool StrCopy(String *T,String S)
{
   if(T==NULL)return false;
   T->data=S.data;
   T->length=S.length;
   return true;
}

判空操作

StrEmpty(S)：判空操作。若S为空串，则返回TRUE，否则返回FALSE。

bool StrEmpty(String S)
{
    if(S.length==0)
		return true;
	else
		return false;
}

打印操作

void PrintString(String S)
{
    if(S.length==0)return;
    char *t=(char *)malloc(sizeof(char));
	for(int i=0;i<S.length;i++)
	{
		t[i]=S.data[i];
	}
	printf("%s\n",t);
	//printf("S->data=%s\n",S->data);
}

求串长

StrLength(S)：求串长。返回串S的元素个数。

int StrLength(String S)
{
   return S.length;
}

清空操作

ClearString(&S)：清空操作。将S清为空串。

void ClearString(String *S)
{
   //free(S);
	S=NULL;
}

串连接

Concat(&T,S1,S2)：串联接。用T返回由S1和S2联接而成的新串

bool Concat(String *S,char *s1,char *s2)
{
    if(S==NULL)return false;
    int s1_len=strlen(s1);
	int s2_len=strlen(s2);
	for(int i=0;i<s1_len;i++)
          S->data[i]=s1[i];
	for(int k=0;k<s2_len;k++)
          S->data[k+i]=s2[k];
    S->length=s1_len+s2_len;
	return true;
}

求子串

SubString(&Sub,S,pos,len)：求子串。用Sub返回串S的第pos个字符起长度为len的子串。

void SubString(String *Sub,String S,int pos,int len)
{
    if(S.length==0||pos<0||len>S.length||pos>S.length||pos+len>S.length)
		return;
	for(int i=0;i<len;i++)
		Sub->data[i]=S.data[pos+i];
	Sub->length=len;
}

定位操作

Index(S,T)：定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的
位置；否则函数值为0。

//定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为-1。
int StrIndex(String S,String T)
{
    int result=-1;
	int i=0;
    String substr;
    InitString(&substr);
	while(i<S.length-T.length+1)
	{
	   	SubString(&substr,S,i,T.length);

		if(StrCompare(substr,T)==0)
		{
		    return i;
		}else
		{
		   i++;
		}
		
	}
	return result;
}

比较操作

StrCompare(S,T)：比较操作。若S>T，则返回值>0；若S=T，则返回值=0；若S

//比较操作。若S>T，则返回值>0；若S=T，则返回值=0；若S
int StrCompare(String S,String T)
{
	for(int i=0;i<S.length&&i<T.length;i++)
	{
	    if(S.data[i]!=T.data[i])
			return S.data[i]-T.data[i];
	}
	return S.length-T.length;
   
}

测试代码

int main(int argc, char* argv[])
{
    String S,T,P,Q,X,Y,Z,substr;
	InitString(&S);
	InitString(&T);
	InitString(&X);
	InitString(&Y);
	InitString(&Z);
	InitString(&P);
	InitString(&Q);
	InitString(&substr);

	//赋值操作
	StrAssign(&S,"Hello World!");
	printf("输出赋值操作字符串:");
    PrintString(S);

    //判断串是否为空
    printf("串S是否为空:%d\n",StrEmpty(S)); 
    printf("串T是否为空:%d\n",StrEmpty(T)); 

    //获取串的长度
    printf("串S的长度:%d\n",StrLength(S)); 
    printf("串T的长度:%d\n",StrLength(T)); 

	StrAssign(&S,"Stay Young!");
	//复制操作
	StrCopy(&T,S);
	printf("输出复制赋值操作字符串:");
	PrintString(T);

    //清空操作
    ClearString(&S);
    printf("清空操作后串S是否为空:%d\n",StrEmpty(S)); 
     
    //串连接
    Concat(&Z,"Keep","Moving!");
	printf("输出串连接操作字符串:");
    PrintString(Z);

	//求子串
	SubString(&substr,S,5,5);
    printf("截取字符串:");
    PrintString(S);
	printf("SubString(&substr,S,5,5)=");
	PrintString(substr);

	//比较操作(第一次没写出来)
	StrAssign(&X,"abstraction");
	StrAssign(&Y,"abstract");
    int result=StrCompare(X,Y);
	printf("StrCompare(X,Y)=%d\n",result);


	//定位操作
	StrAssign(&P,"wangdao");
	StrAssign(&Q,"dao");
	printf("P:wangdao,Q:dao\n");
    int result_index=StrIndex(P,Q);
    printf("StrIndex(P,Q)=%d\n",result_index);
    return 0;


}

测试结果

输出赋值操作字符串:Hello World!
串S是否为空:0
串T是否为空:1
串S的长度:12
串T的长度:0
输出复制赋值操作字符串:Stay Young!
清空操作后串S是否为空:0
输出串连接操作字符串:KeepMoving!
截取字符串:Stay Young!
SubString(&substr,S,5,5)=Young
StrCompare(X,Y)=3
P:wangdao,Q:dao
StrIndex(P,Q)=4