学习字符串后的感受

字符串的基本概念：

                               字符串是由0个或多个字符构成的有限数列，一般可表示如下形式：

                                                                     “c1c2....cn”   (n>=0)

字符串类的定义：字符串是元素类型为字符型的特殊线性表，它与一般线性表的不同之处在于，其每个元素的类型一定为字符型，而不能为其它类型；

字符串的储存方式：顺序储存和链式储存；

字符串的基本操作：插入，删除，连接，求子串运算；

定义字符串结构体：

#define MAXSIZE 100
typedef struct {
	char str[MAXSIZE];
	int length;
}seqstring;

顺序储存的字符串基本操作代码：

//函数功能：顺序串的插入
//函数参数表：S为指向seqstring类型的指针变量
                       //整型变量i为插入变量
                       //T为seqstring类型,表示插入的子串
//函数返回值:空

void strinsert(seqstring *S, int i, seqstring T)
{
	int k;
	if (i<1 || i>S->length + 1 || S->length + T.length > MAXSIZE - 1)
		printf("cannot insert!\n");
	else
	{
		for (k = S->length - 1;k >= i - 1;--k)   //后移
			S->str[T.length + k] = S->str[k];
		for (k = 0;k < T.length;++k)
			S->str[i + k - 1] = T.str[k];
		S->length = S->length + T.length;
		S->str[S->length] = '\0';
	}
}
//函数功能：顺序串的删除
/*函数参数：S为指向seqstring类型的指针变量
*           整型变量i为删除的位置
*           整型变量len为所删除的子串长度*/
//函数返回值：空

void strdelete(seqstring *S, int i, int len)
{
	int k;
	if (i<1 || i>S->length || i + len - 1>S->length)
		printf("cannot delete!\n");
	else
	{
		for (k = i + len - 1;k < S->length;++k)
			S->str[k - len] = S->str[k];
		S->length = S->length - len;
		S->str[S->length] = '\0';
	}
}
//函数功能：顺序串的链接
//函数参数：S1，S2均为seqstring类型
//函数返回值：指向seqstring的指针类型

seqstring* strconcat(seqstring S1, seqstring S2)
{
	int i;
	seqstring *r;
	if (S1.length + S2.length > MAXSIZE - 1)
	{
		printf("cannot concate");
		return(NULL);
	}
	else
	{
		r = (seqstring*)malloc(sizeof(seqstring));
		//将S1拷贝到r字符数组的前端
		for (i = 0;i < S1.length;++i)  r->str[i] = S1.str[i];
		//将S2拷贝到r字符数组的后端
		for (i = 0;i < S2.length;++i)  r->str[S1.length + i] = S2.str[i];
		r->length = S1.length + S2.length;
		r->str[r->length] = '\0';
	}
	return (r);
}
//函数功能：求给定顺序串的字串
//函数参数：S为seqstring类型
            //整型变量i为所取字串的其始位置
            //整型变量len为所取字串的长度
//函数返回值：指向seqstring的指针变量

seqstring *substring(seqstring S, int i, int len)
{
	int k;
	seqstring *r;
	if (i<1 || i>S.length || i + len - 1>S.length)
	{
		printf("error!\n");
		return (NULL);
	}
	else
	{
		r = (seqstring *)malloc(sizeof(seqstring));
		for (k = 0;k < len;++k)
			r->str[k] = S.str[i + k - 1];
		r->length = len;
		r->str[r->length] = '\0';
	}
	return (r);
}

链式字符串的定义：

typedef struct node
{
	char data;
	struct node *next;
}linkstrnode;
typedef linkstrnode *linkstring;

链式储存的字符串基本操作：

//函数功能：链式串的创建
//函数参数：S为指向linkstring类型的指针变量
//函数返回值：空

void strcreate(linkstring *S)
{
	char ch;
	linkstrnode *p, *r;
	*S = NULL; r = NULL;  //用r始终指向当前链式串的最后一个字符对应的结点
	while ((ch = getchar()) != '\n')
	{
		p = (linkstrnode *)malloc(sizeof(linkstrnode));
		p->data = ch;
		if (*S == NULL)
			*S = p;
		else
			r->next = p;
		r = p;
	}
	if (r != NULL) 
	{
		r->next = NULL;
	}
}
//函数功能：链式串的插入
//函数参数：S为指向linkstring类型的指针变量
          //整型变量i为插入的位置
          //T为linkstring类型，表示插入的字串
//函数返回值：空
void strinsert(linkstring *S, int i, linkstring T)
{
	int k;
	linkstring p, q;
	p = *S, k = 1;
	while (p&&k < i - 1)
	{
		p = p->next;k++;
	}
	if (!p)   printf("error\n");
	else
	{
		q = T;
		while (q->next)  q = q->next;
		q->next = p->next;
		p->next = T;
	}
}

//函数功能：链式串的删除
//函数参数：S指向linkstring类型的指针变量
          //整型变量i为删除的其实位置
         //整型变量len为删除的字串长度
//函数返回值：空

void strdelete(linkstring *S, int i, int len)
{
	int k;
	linkstring p, q, r;
	p = *S, q = NULL, k = i;
	while (p&&k < i)
	{
		q = p;
		p = p->next;
		k++;
	}
	if (!p)  printf("error2\n");
	else
	{
		if (!q) { r = *S; *S = p->next; }
		else
		{
			r = q->next;  q->next = p->next;
		}
		p->next = NULL;
		while (r != NULL)
		{
			p = r;r->next;free(p);
		}
	}
}
//函数功能：链式串的链接
//函数参数：S1指向linkstring类型的指针变量
          //S2为linkstring类型
//函数返回值：空
void strconcat(linkstring *S1, linkstring S2)
{
	linkstring p;
	if (!(*S1))
	{
		*S1 = S2; return;
	}
	else
		if (S2)
		{
			p = *S1;
			while (p->next)   p = p->next;
			p->next = S2;
		}
}
//函数功能：求给定链式串的字串
//函数参数：S为linkstring类型
          //整型变量i为所取字串的起始位置
          //整型变量len为所取子串的长度
//函数返回值：linkstring类型

linkstring substring(linkstring S, int i, int len)
{
	int k;
	linkstring p, q, r, t;
	p = S, k = 1;
	while (p && k < i) { p = p->next;++k; }
	if (!p) { printf("error1\n");return (NULL); }
	else {
		r = (linkstring)malloc(sizeof(linkstrnode));
		r->data = p->data;r->next = NULL;
		k = 1;q = r;
		while (p->next && k < len)
		{
			p = p->next;++k;
			t = (linkstring)malloc(sizeof(linkstrnode));
			t->data = p->data;
			q->next = t;q = t;
		}
		if (k < len) { printf("error2\n");return (NULL); }
		else {
			q->next = NULL; return (r);
		}
	}
}

对于字符串还有其模式匹配（朴素模式匹配算法和KMP快速匹配算法）：

//函数功能：字符串的朴素模式匹配算法的实现
//函数参数：模式p和正文t均为seqstring类型
//函数返回值：若匹配成功则返回p在t中首次出现的起始位置
            //若匹配不成功则返回-1
int index(seqstring p, seqstring t)
{
	int i, j, succ;
	i = 0;succ = 0;
	while ((j <= t.length - p.length) && (!succ))
	{
		j = 0;succ = 1;
		while ((j <= p.length - 1) && succ)
			if (p.str[j] == t.str[i + j]) j++;
			else    succ = 0;
		++i;
	}
	if (succ) return (i - 1);
	else      return (-1);
}
//函数功能：根据模式p的组成求其对应的next数组值
//函数参数：p为seqstring类型,表示模式
          //next为整型数组,用于存放模式p对应的next数组值
//函数返回值：空
void getnext(seqstring p, int next[])
{
	int i, j;
	i = 0;j = -1;
	while (i < p.length)
	{
		if (j == -1 || p.str[i] == p.str[j])
		{
			++i;++j;next[i] = j;
		}
		else
			j = next[j];
	}
	for (i = 0;i < p.length;++i)
		printf("%d", next[i]);
}
//函数功能：字符串KMP模式匹配算法的实现
//函数参数：t和p均为seqstring类型,t表示正文，p表示模式
          //整型数组next存放模式P对应的next值
 //函数返回值：若匹配成功则返回p在t中首次出现的位置
             //如匹配不成功则返回-1
int kmp(seqstring t, seqstring p, int next[])
{
	int i, j;
	i = 0;j = 0;
	while (i < t.length && j < p.length)
	{
		if (j == -1 || t.str[i] == p.str[j])
		{
			i++;j++;
		}
		else j = next[j];
	}
	if (j == p.length)  return (i - p.length);
	else return (-1);
}