串的数据结构（C）

1.串的基本概念

(1）串(又称字符串)是由n(n≥0)个字符组成的有限序列。（它是数据元素为单个字符的特殊线性表。）

(２)串长　 串中字符的个数（n≥0）。
(３)空串 串中字符的个数为0 时称为空串  。
(４)空白串　由一个或多个空格符组成的串。
(５)子串　 串S中任意个连续的字符序列叫S的子串; S叫主串。
(６)子串位置　子串的第一个字符在主串中的序号。
(７)字符位置　字符在串中的序号。
(８)串相等　 串长度相等，且对应位置上字符相等。（即两个串中的字符序列一一对应相等。）

2.串的抽象数据类型

数据集合：串的数据集合可以表示为字符序列 s0,s1, ……,sn-1，每个数据元素的数据类型为字符类型。
操作集合：
(1)初始化串　Initiate(S)
(2)赋值　 Assign(S,T)
(3)求串长度　Length(S)
(4)比较　 Compare(S,T) :有相等和不相等两种比较结果，还有大于、等于和小于三种比较结果
(5)插入　 Insert(S,pos,T)
(6)删除　 Delete(S,pos,len)
(7)取子串　 SubString(S,pos,len)
(8)查找子串　Search(S,start,T)
(9)替换子串　Replace(S,start,T,V)

3.串和线性表的比较

相同之处：都是线性结构
不如之处：（1）线性表的数据元素类型为任意类型；而串的数据元素类型为字符类型。（2）线性表的插入和删除操作都是只对一个数据元素；而串的插入和删除操作都是对一个子串进行的。（3）串还有一些不同于线性表的其他操作

4.C语言的串函数

调用库函数的头文件#include <string.h>

串长度：int strlen(char *str);
串拷贝：char *strcpy(char *str1,char *str2);
串比较：int strcmp(char *str1,char *str2);
字符定位：char *strchr(char *str,char ch);
子串查找: char *strstr(char *s1,char *s2);
串连接：char *strcat(char *str1,char *str2);
…

5.串的存储结构
（1）.串的顺序存储结构
串的顺序存储结构就是用一个字符类型的数组存放串的所有字符，此时，表示串的长度的方法有两种：
一种方法是设置一个串的长度参数，此种方法的优点是便于在算法中用长度参数控制循环过程；另一种方法是在串值的末尾添加结束标记，此种方法的优点是便于系统自动实现。
由于不同的内存分配方式定义的数组决定了串的顺序存储结构也有两种：
静态数组结构：用静态内存分配方法定义的数组。由于此时数组元素的个数是在编译是确定的，在运行时是不可改变的，所以也称为定长数组结构。
①静态数组结构：用静态内存分配方法定义的数组。由于此时数组元素的个数是在编译是确定的，在运行时是不可改变的，所以也称为定长数组结构。

//其类成员变量包括：
typedef struct
{
          char str[MaxSize];
          int length;
} String;

②动态数组结构：用动态内存分配方法定义的数组。此时数组元素的个数是在用户申请动态数组空间时才确定的,因此，动态数组结构体定义中要增加一个指出动态数组个数的域。

typedef struct
{
          char *str;
          int maxLength;			
          int length;
} DString;

其中，str指向动态数组的首地址， maxLength表示动态数组的最大个数， length表示串的当前长度，必须满足length ≤ maxLength。

（2）串的链式存储结构
它分为单字符结点和块链两种。

//单字符结点链
typedef struct Node
{
          char str;
	      struct Node *next;
} SCharNode;

//块链                 
typedef struct Node
{
          char str[Number];
          struct Node *next;
} NCharNode;

在实际应用中，串基本上采用动态数组存储结构。

6.串的动态数组存储结构

//串的动态数组结构体定义为：
//串的动态数组结构体定义为：
typedef struct
{
    char *str;
    int maxLength;
    int length;
} DString;

//初始化操作
void Initiate(DString *S, int max, char *string)
{
    int i, m;
    S->length = strlen(string);
    if (S->length > max)
        m = S->length;
    else
        m = max;
    S->maxLength = m;
    S->str = (char *)malloc(sizeof(char) * m);
    for (i = 0; i < S->length; i++)
        S->str[i] = string[i];
}

/* 
//第二种方法          
typedef struct   
{        
    char *str;
	int length;
} DString;
void Initiate(DString *S, char *string)
{
    int i;
	S->length = strlen(string);
	S->str = (char *)malloc(sizeof(char)* S->length); 					
	for(i = 0; i < S->length; i++)
   {
	    S->str[i] = string[i];
    }
*/

//插入子串操作
int Insert(DString *S, int pos, DString T)
{
    int i;
    char *p;
    if (pos < 0)
    {
        printf("参数pos出错！");
        return 0;
    }
    else
    {
        if (S->length + T.length > S->maxLength)
            p = (char *)realloc(S->str, (S->length + T.length) * sizeof(char));
        for (i = S->length - 1; i >= pos; i--)
            S->str[i + T.length] = S->str[i];
        for (i = 0; i < T.length; i++)
            S->str[pos + i] = T.str[i];
        S->length = S->length + T.length;
        return 1;
    }
}

//删除子串操作
int Delete(DString *S, int pos, int len)
{
    int i;
    if (S->length <= 0)
    {
        printf("数组中未存放字符无元素可删! \n");
        return 0;
    }
    else if (pos < 0 || len < 0 || pos + len > S->length)
    {
        printf("参数pos和len不合法\n");
        return 0;
    }
    else
    {
        for (i = pos + len; i <= S->length - 1; i++)
            S->str[i - len] = S->str[i];
        S->length = S->length - len;
        return 1;
    }
}

//取子串操作
int SubString(DString *S, int pos, int len, DString *T)
{
    int i;
    if (pos < 0 || len < 0 || pos + len > S->length)
    {
        printf("参数pos和len出错！");
        return 0;
    }
    else
    {
        for (i = 0; i < len; i++)
            T->str[i] = S->str[pos + i];
        T->length = len;
        return 1;
    }
}

//撤消操作
void Destroy(DString *S)
{
    free(S->str);
    S->maxLength = 0;
    S->length = 0;
}