数据结构C语言实现之串

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//定义函数结果状态码
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0


//定义数据类型
//typedef int ElemType ;

//定义顺序串空间大小，最多存放40个字符
#define STRINGSIZE 20

//定义程序返回状态类型
typedef int State;

// 定义顺序串结构体
typedef struct
{
 char ch[STRINGSIZE];//按串长分配存储空间
 int length;//存放串长
}String;


/*************************************************
Function:       StrAssign
Description:    生成一个其值等于字符串常量s的串T
Input:          串 String T
                字符串指针 char *s
Output:
Return:         成功返回OK，失败返回ERROR
Others:
*************************************************/
State StrAssign(String *T, char *s)
{
    int i,length = strlen(s);
    if(length > STRINGSIZE)
    {
        printf("The s is too long!");
        return ERROR;
    }

    for(i = 0; i < length; i++)
        {
            T->ch[i] = s[i];
        }
    T->length = length;
    return OK;
}

/*************************************************
Function:       StrCopy
Description:    由串S复制得串T
Input:          串 String *T
                串 String *S
Output:
Return:         成功返回OK，失败返回ERROR
Others:
*************************************************/
State StrCopy(String *T, String *S)
{
    int i,length = S->length;
    for(i = 0; i < length; i++)
        T->ch[i] = S->ch[i];
    T->length = length;
    return OK;
}

/*************************************************
Function:       StrEmpty
Description:    判断T是否为空串
Input:          串 String *T
Output:
Return:         为空返回TRUE，不为空返回FALSE
Others:
*************************************************/
State StrEmpty(String *T)
{
    if(T->length == 0)
        return TRUE;
    else
        return FALSE;


}

/*************************************************
Function:       StrCompare
Description:    比较两个非空串的大小
Input:          串 String *T
                串 String *S
Output:
Return:         若S>T,返回值>0, S<T,返回值<0, S=T,返回值=0
Others:
*************************************************/
int StrCompare(String *S,String *T)
{
    int i;
    //如果有非空串，程序退出,若返回相关标志怕与下面返回的差值冲突
    if((S->length == 0) || (T->length == 0))
        exit(1);

    for(i=0;(i<S->length) && (i<T->length);i++)
        if(S->ch[i] != T->ch[i])
            return S->ch[i] - T->ch[i];
    return S->length - T->length;

}

/*************************************************
Function:       StrLength
Description:    返回串的长度
Input:          串 String *S
Output:
Return:         int
Others:
*************************************************/
int StrLength(String *S)
{
    return S->length;
}

/*************************************************
Function:       StrClear
Description:    清空串
Input:          串 String *S
Output:
Return:         成功返回OK
Others:
*************************************************/
State StrClear(String *S)
{
    S->length = 0;
    return OK;
}

/*************************************************
Function:       Concat
Description:    用T返回由S1和S2连接而成的串
Input:          String *T
                String *S1
                String *S2
Output:
Return:         成功返回OK,若T装不下则装入截断后的内容，返回ERROR
Others:
*************************************************/
State Concat(String *T,String *S1,String *S2)
{
    int i,j;
    if(S1->length+S2->length <= STRINGSIZE)
    {
        for(i=0;i<S1->length;i++)
            T->ch[i] = S1->ch[i];

        for(j=0;j<S2->length;i++,j++)
            T->ch[i] = S2->ch[j];

        T->length = S1->length + S2->length;
        return OK;

    }
    else //截断S2
    {
        for(i=0;i<S1->length;i++)
        {
            T->ch[i] = S1->ch[i];
        }
        for(j=0;i < STRINGSIZE;i++,j++)
        {
            T->ch[i] = S2->ch[j];
        }
        T->length = STRINGSIZE;
        return ERROR;
    }

}

/*************************************************
Function:       SubString
Description:    用Sub返回串S中自pos位置开始长度为len的字串
Input:          String *Sub
                String *S
                int pos    pos>=1 && pos<=S->length
                int len    len>=0 && pos+len <= S->length+1 //注意要+1
Output:
Return:         成功返回OK，pos与len不合适返回ERROR
Others:
*************************************************/
State SubString(String *Sub,String *S,int pos,int len)
{
    int i,j;
    if((pos>=1 && pos<=S->length) && (len>=0 && len+pos<=S->length+1))
    {
        for(i=0,j=pos-1;i<len;i++,j++)
        {
            Sub->ch[i]=S->ch[j];
        }
        Sub->length = len;
        return TRUE;
    }
    return ERROR;
}

/*************************************************
Function:       Index
Description:    若主串S中第pos个字符之后存在与T相等的子串
                则返回第一个这样的子串在S中的位置，否则返回0
Input:          String *S  非空，不做检查
                String *T  非空，不做检查
                int pos    pos>=1 && pos<=S->length
Output:
Return:
Others:
*************************************************/
int Index(String *S,String *T,int pos)
{
    int m,n,i;
    String sub;
    if(pos>0)
    {
        n = S->length;
        m = T->length;
        i = pos;
        while(i <= n-m+1)
        {
            SubString(&sub,S,i,m);
            if(0 != StrCompare(&sub,T))
            {
                ++i;
            }
            else
            {
                return i;
            }
        }
    }
    return 0;
}

/*************************************************
Function:       StrInsert
Description:    在串S的自第pos个字符处插入串T
Input:          String *S
                int pos   1<= pos <= S->length+1
                String *T  非空
Output:
Return:         完全插入且原串无溢出返回OK,
                部分插入
                全部插入但原串溢出 返回ERROR
Others:         不满意
*************************************************/
State StrInsert(String *S,int pos,String *T)
{
    int len=T->length,i,j;
    //插入位置不合法
    if(pos<1 && pos>S->length+1)
        return ERROR;

    //  完全插入
    if(S->length+len <= STRINGSIZE)
    {
        for(i=S->length-1; i >= pos-1; i--)
            S->ch[i+len]=S->ch[i];
        for(i=0; i<len; i++)
            S->ch[pos-1+i] = T->ch[i];
        S->length = S->length+T->length;
        return TRUE;
    }
    else if(pos-1+len <= STRINGSIZE)//  完全插入但原串溢出
        {
            for(i=STRINGSIZE-1-len; i>=pos-1; i--)
                S->ch[i+len] = S->ch[i];
            for(i=0; i<len; i++)
                S->ch[pos-1+i]=T->ch[i];
            S->length = STRINGSIZE;
            return FALSE;
        }
        else    //部分插入
        {
            for(i=pos-1,j=0; i<STRINGSIZE; i++,j++)
                S->ch[i] = T->ch[j];
            S->length = STRINGSIZE;
            return FALSE;

        }

}

/*************************************************
Function:       StrDelete
Description:    删除串S中从pos位置起长度为len的子串
Input:          String *S 非空，不判断
                int pos   pos>0 && pos<=S->length-len+1
                int len   len>0 && pos<=S->length-len+1
Output:
Return:         成功返回OK，否则返回ERROR
Others:
*************************************************/
State StrDelete(String *S,int pos,int len)
{
    int i;
    //验证pos 和 len的范围
    if(pos<1 || pos>S->length-len+1 || len<0)
		return ERROR;

    for(i=pos-1+len; i<S->length; i++)
		S->ch[i-len] = S->ch[i];
	S->length -= len;
	return OK;

}

/*************************************************
Function:       StrDestroy
Description:    销毁串
Input:          String *S 非空，不判断
Output:
Return:         成功返回OK
Others:
*************************************************/
State StrDestroy(String *S)
{
    free(S);
    return OK;
}