数据结构 顺序串笔记

/*
数据结构——串笔记
    串：由零个或多个字符组成的有限序列。 
    串也有两种储存方式，顺序储存和链式储存 
    1.顺序表示的串——顺序串
        一般使用字符型数组储存。
        确定串的长度有两种方法。一是：在串的末尾加一个结束标记（在C语言
        中系统自动在串值的末尾加一个''作为结束标记 ），再使用 strlen
        函数得到串的长度。二是：增加一个变量 len 用来储存串的长度。 
*/ 

// 顺序串的实现即基本操作

# include <stdio.h>
# include <stdlib.h>
# include <malloc.h>

// 定义一个穿的最大长度 
# define MAXSIZE 50  

// 储存结构，此处采用增加一个变量 len 用来储存串的长度 
struct String
{
    char * str;
    int len;
}; 
// 串的创建
void Create_String(String * S); 
// 串的初始化
void Init_String(String * S); 
// 串的赋值 
void String_Assign(String * S, char * str);
// 串的遍历
void Travel_String(String * S); 
// 判断串是否为空
bool Is_Empty(String * S);
// 求串的长度
int String_Length(String * S);
// 串的复制
void String_Copy(String * S, String * T);
// 比较两个串的大小,返回两个串的长度的差值 
int String_Compare(String * S, String * T);
// 在串S的pos位置插入串T 
void String_Insert(String * S, String * T, int pos);
// 删除串S中从位置pos开始的len个字符
bool String_Delete(String * S, int pos, int len);
// 将串T连接到串S的末尾 
void Strint_Concat(String * S, String * T);
// 清空串
void String_Clear(String * S); 


int main(void)
{
    String str1;
    Create_String(&str1);
    Init_String(&str1);
    char ch1[20] = "AAAA";
    String_Assign(&str1, ch1);
    Travel_String(&str1);
    
    return 0;
}

void Create_String(String * S)
{
    S->str = (char *)malloc(sizeof(char) * MAXSIZE);
    if (NULL == S->str)
    {
        printf("动态内存分配失败！
");
        exit(-1);
    }
    
    return;
}

void Init_String(String * S)
{
    S->len = 0;
    
    return;
}

void String_Assign(String * S, char * str)
{
    int cnt;
    for (cnt = 0; str[cnt] != ''; ++cnt)
    {
        S->str[cnt] = str[cnt];
    }
    S->len = cnt;
    
    return;
}

void Travel_String(String * S)
{
    int i;
    for (i = 0; i < S->len; ++i)
    {
        printf("%c", S->str[i]);
    }
    printf("
");
    
    return;
}

bool Is_Empty(String * S)
{
    if (0 == S->len)
    {
        return true;
    }
    else
    {
        return false;
    }
}

int String_Length(String * S)
{
    return S->len;
}

void String_Copy(String * S, String * T)
{
    int i;
    S->len = T->len;
    for (i = 0; i < T->len; ++i)
    {
        S->str[i] = T->str[i];
    }
    S->str[S->len] = ''; 
    
    return;
}

int String_Compare(String * S, String * T)
{
    int i;
    for (i = 0; i < T->len; ++i)
    {
        if (S->str[i] != T->str[i])
        {
            return (S->str[i] - T->str[i]);    //如果有不相等的字符，返回两字符的ASCII码差值 
        }
    }
    return (S->len - T->len);  // 如果比较完毕，返回两串长度的差值 
}

void String_Insert(String * S, String * T, int pos)
{
    int i;
    if ((pos < 0) || ((pos-1) > S->len))
    {
        printf("插入位置有误！
");
        exit(-1);
    }
    // 细节说明 pos位置的下标为 pos,即是在S串的第pos个字符后面插入 
    if ((pos + T->len) <= MAXSIZE && (S->len + T->len) > MAXSIZE)  // 子串T可完全插入，但位置不够，S串需要有字符被截取掉 
    {
        for (i = 0; i < (MAXSIZE - pos - T->len); ++i)  // 原S串中从pos+1个字符开始有MAXSIZE - pos - T->len个字符需要后移 
        {
            S->str[MAXSIZE - i - 1] = S->str[MAXSIZE - T->len -i - 1];
        }
        for (i = 0; i < T->len; ++i)
        {
            S->str[pos + i] = T->str[i];
        } 
        S->len = MAXSIZE;
    }
    else if ((pos + T->len) > MAXSIZE)  // 子串T不能被完整插入
    {
        for (i = 0; i < MAXSIZE - pos; ++i)   // 插入字符到串满 
        {
            S->str[pos+i] = T->str[i];
        }
        S->len = MAXSIZE;
    } 
    else  // 子串T可以被完全插入,且串S不需要截取 
    {
        for (i = 0; i < (T->len - pos); ++i)  // 原S串中从pos+1个字符开始每个向后移T->len位 
        {
            S->str[S->len + T->len - 1 -i] = S->str[S->len - 1 - i];
        }
        for (i = 0; i < T->len; ++i)
        {
            S->str[pos + i] = T->str[i];
        }
        S->len += T->len;
    } 
    
    return;
} 

bool String_Delete(String * S, int pos, int len)
{
    int i;
    if (pos < 0 || len < 0 || pos + len - 1 > S->len)
    {
        printf("删除位置不对！
");
        return false;
    }
    else
    {
        for (i = pos+len; i <= S->len-1; ++i)
        {
            S->str[i - len] = S->str[i];
        }
        S->len -= len;
        return true; 
    }
}

void Strint_Concat(String * S, String * T)
{
    int i;
    if (S->len + T->len <= MAXSIZE)  // 连接后串的长度小于MAXSIZE
    {
        for (i = 0; i < T->len; ++i)
        {
            S->str[S->len + i] = T->str[i];
        } 
        S->len += T->len;
    }
    else  // 连接后串的长度大于MAXSIZE
    {
        for (i = 0; i < MAXSIZE-S->len; ++i)
        {
            S->str[S->len + i] = T->str[i];
        }
        S->len = MAXSIZE;
    } 
    
    return;
}

void String_Clear(String * S)
{
    free(S->str);
    S->str = NULL;
    S->len = 0;
}