详解顺序字符串

定义和特点

定义

顺序字符串是由零个或多个字符组成的有限序列，一般记作：S="a1a2a3...an"。其中，S是串名，用双引号括起来的字符序列是串的值，ai(1≤i≤n)可以是字母、数字或其他字符，n是串的长度。当n=0时，S为空串（null string）。串中任意一个连续的字符组成的子序列称为该字符的子串。相应的包含子串的串称为主串。通常将字符在串中的序号称为该字符在串中的位置。

特点

顺序字符串具有可修改性，即可以通过修改字符串中某个位置的字符来改变整个字符串的值；具有随机访问性，即可以通过下标运算符访问字符串中的任意字符；具有可重复性，即可以多次复制同一个字符串。

基本运算

1. 建立字符串。例如，建立串s="abcdefghefghijklmn"和串s1="xyz"。
2. 输出字符串。例如，输出串s。
3. 字符串的长度。例如，输出串s的长度。
4. 插入字符串。例如，在串s的第九个字符位置插入串s1而产生串s2。
5. 删除字符串。例如，删除串s的第二个字符开始的五个字符而产生串s2。
6. 替换字符串。例如，将串s第二个字符开始的五个字符替换成串s1而产生串s2。
7. 提取字符串。例如，提取串s的第二个字符开始的10个字符而产生串s2。
8. 连接字符串。例如，将串s1和串s2连接起来而产生串s3。

实现

初始化

这个函数 init 是一个用于初始化字符串结构的函数。它接受两个参数：一个是指向字符串结构的指针 S，另一个是整数 max，表示字符串的最大长度。

int init(sstring *S, int max)
{
	S->data = (char*)malloc(sizeof(char)*max);

	if(!S->data)
	{
		printf("申请内存失败！1000");
		return 1000;
	}
	S->max = max;
	S->len = 0;
}

从字符常量拷贝

这个函数 sstrcpy 的作用是将一个普通的 C 字符串（from）复制到特定的 sstring 结构中（S）。 首先，函数通过 strlen(from) 获取输入字符串 from 的长度。然后，它检查这个长度是否超过了 S->max（即 S 所指向的字符串的最大长度）。如果超过了，它会打印错误信息 "超出了字符串S的长度！1001" 并返回 1001。 如果长度没有超过，那么函数会开始复制字符。它通过一个循环，从 from 的第 i 个字符复制到 S->data 的第 i 个字符。复制完成后，将 S->data 的最后一个字符设置为 null 字符（'\0'），表示字符串的结束。 最后，它将 S->len（即 S 所指向的字符串的长度）设置为复制的字符串的长度，并返回 0，表示操作成功。

/*从字符常量拷贝*/
int sstrcpy(sstring *S, char* from)
{
	int i;
	int len = strlen(from);

	if(len>S->max)
	{
		printf("超出了字符串S的长度！1001\n");
		return 1001;
	}
	for(i=0;i<len;i++)
	{
		S->data[i] = from[i];
	}
	S->data[i] = '\0';
	S->len = len;
	return 0;
}

模式匹配

检查一个主字符串 S 是否包含一个子字符串 sub。如果包含，它返回子字符串在主字符串中第一次出现的位置；如果不包含，它返回 -1。

int sstrmatch(sstring *S, sstring *sub)
{
	int i, j, k;
	int m = S->len;
	int n = sub->len;

	for(i=0;i<=m-n;i++)
	{
		j=0;
		k=i;
		while(j<n && S->data[k] == sub->data[j])
		{
			j++;
			k++;
		}
		if(j==n)
		{
			return i;
		}
	}
	return -1;
}

串比较

对两个字符串进行比较，并返回它们之间的相对顺序。根据这个函数，如果字符串s1在字典上小于字符串s2，则返回-1；如果大于，则返回1；如果相等，则返回0。

//串比较
int sstring_compare(const sstring* s1, const sstring* s2)
{
    int i;
    int result;

    // 比较两个字符串的长度
    if (s1->len < s2->len) {
        return -1;
    } else if (s1->len > s2->len) {
        return 1;
    }

    // 长度相等，比较每个字符
    for (i = 0; i < s1->len; i++) {
        if (s1->data[i] < s2->data[i]) {
            return -1;
        } else if (s1->data[i] > s2->data[i]) {
            return 1;
        }
    }

    // 字符串相等
    return 0;
}

串长

通过访问指针的成员变量len，可以获取字符串的长度。

int slength(sstring* str) {
    return str->len;
}

串的拼接

首先检查两个字符串的总长度是否超过了第一个字符串的最大长度。如果超过了，我们就使用realloc函数来重新分配内存，并将新的长度赋值给第一个字符串的最大长度。然后，我们使用strcat函数来拼接两个字符串，并更新第一个字符串的长度。

void strcat_sstring(sstring* s1, sstring* s2) {
    if (s1->len + s2->len > s1->max) {
        s1->data = (char*)realloc(s1->data, (s1->len + s2->len + 1) * sizeof(char));
        s1->max = s1->len + s2->len + 1;
    }
    strcat(s1->data + s1->len, s2->data);
    s1->len += s2->len;
}

运行截图

完整代码

1. sstring.h

/*
	sstring.h
	顺序字符串
*/

typedef struct
{
	char* data;
	int max;
	int len;
}sstring;

/*初始化串*/
int init(sstring *S, int max);
/*从字符常量拷贝*/
int sstrcpy(sstring *S, char* from);

/*模式匹配*/
int sstrmatch(sstring *S, sstring *sub);

//串比较
int sstring_compare(const sstring* s1, const sstring* s2);

//串长
int slength(sstring* str);

//串的拼接
void strcat_sstring(sstring* s1, sstring* s2);

2. sstring.c

/*
	sstring.c

*/
#include "sstring.h"


/*初始化串*/
int init(sstring *S, int max)
{
	S->data = (char*)malloc(sizeof(char)*max);

	if(!S->data)
	{
		printf("申请内存失败！1000");
		return 1000;
	}
	S->max = max;
	S->len = 0;
}


/*从字符常量拷贝*/
int sstrcpy(sstring *S, char* from)
{
	int i;
	int len = strlen(from);

	if(len>S->max)
	{
		printf("超出了字符串S的长度！1001\n");
		return 1001;
	}
	for(i=0;i<len;i++)
	{
		S->data[i] = from[i];
	}
	S->data[i] = '\0';
	S->len = len;
	return 0;
}


/*模式匹配*/
int sstrmatch(sstring *S, sstring *sub)
{
	int i, j, k;
	int m = S->len;
	int n = sub->len;

	for(i=0;i<=m-n;i++)
	{
		j=0;
		k=i;
		while(j<n && S->data[k] == sub->data[j])
		{
			j++;
			k++;
		}
		if(j==n)
		{
			return i;
		}
	}
	return -1;
}


//串比较
int sstring_compare(const sstring* s1, const sstring* s2)
{
    int i;
    int result;

    // 比较两个字符串的长度
    if (s1->len < s2->len) {
        return -1;
    } else if (s1->len > s2->len) {
        return 1;
    }

    // 长度相等，比较每个字符
    for (i = 0; i < s1->len; i++) {
        if (s1->data[i] < s2->data[i]) {
            return -1;
        } else if (s1->data[i] > s2->data[i]) {
            return 1;
        }
    }

    // 字符串相等
    return 0;
}

//串长
int slength(sstring* str) {
    return str->len;
}

//串的拼接
void strcat_sstring(sstring* s1, sstring* s2) {
    if (s1->len + s2->len > s1->max) {
        s1->data = (char*)realloc(s1->data, (s1->len + s2->len + 1) * sizeof(char));
        s1->max = s1->len + s2->len + 1;
    }
    strcat(s1->data + s1->len, s2->data);
    s1->len += s2->len;
}

3. main.c

#include <stdio.h>
#include "sstring.h"
#include <string.h>
#include <stdlib.h>
int main(int argc, char* argv[])
{
	
	sstring S;
	sstring sub;
	int index;
	char str1[100];
	char str2[100];
	int cmd;

	int result;
    char welcome[] = "(?ω?)没钱";
	int i = 0; 
	int m = 0; 
	int n = 0;
    for(i=0;i<strlen(welcome);i++)
	{
		printf("%c",welcome[i]);
		for(m=0;m<10000;m++)
			for(n=0;n<1000;n++)
			{
				;
			}
	}
	printf("\n\n\n");

	do
	{	
		printf("-----------串演示-----------\n");
		printf(" 1. 初始化\n");
		printf(" 2. 输入串\n");
		printf(" 3. 从字符常量拷贝\n");
		printf(" 4. 模式匹配？\n");
		printf(" 5. 串比较\n");
		printf(" 6. 串长\n");
		printf(" 7. 输出串\n");
		printf(" 8. 串的拼接\n");
		printf(" 9. 帮助\n");
		printf(" 0. 退出\n");
		printf(" 请选择（0~6）：");
		scanf("%d",&cmd);
		switch(cmd){
		case 1:
			init(&S, 1000);
			init(&sub, 100);
			printf("初始化成功！\n");
			break;
		case 2:
			printf("请输入主串：");
			scanf("%s", str1);
			printf("请输入子串：");
			scanf("%s", str2);
			break;
		case 3:
			sstrcpy(&S, str1);
			sstrcpy(&sub, str2);
			printf("从字符常量拷贝已完成！\n");
			break;
		case 4:
			index = sstrmatch(&S,&sub);
			if(index>=0)
			{
				printf("匹配成功，子串在主串的%d位置\n", index); 
			}
			else
			{
				printf("主串中不存在子串！\n");
			}
			break;
		case 5:
			if(sstring_compare(&S,&sub) == 1){
				printf("主串的长度大于子串的长度\n");
			}else if(sstring_compare(&S,&sub) == -1){
				printf("主符串的长度小于子串的长度\n");
			}
			else if(sstring_compare(&S,&sub) == 0){
				printf("两个字符串相等\n");
			}
			else printf("主串和子串的长度相等但字符不一样\n");
			break;
		case 6:
			printf("主串：%s的长度为%d\n",str1,slength(&S));
			printf("子串：%s的长度为%d\n",str2,slength(&sub));
			break;
		case 7:
		    printf("主串打印：%s,",S.data);
		    printf("子串打印：%s\n",sub.data);
		    break;
		case 8:
		    strcat_sstring(&S, &sub);
		    printf("主串和子串的拼接：%s\n",S.data);	
		    break;
		case 9:
		    printf("本程序为顺序字符串的演示程序，由许娜设计开发，\n本人作业如果问题，尽请指教学习！\n");
		    break;
		}
		
	}while(cmd!=0);
	

	return 0;
}

小结

顺序字符串是一种常见的字符串表示方式，它按照字符的顺序排列，从左到右，从上到下。这种表示方式具有以下特点：

1. 顺序排列：顺序字符串按照字符的顺序排列，每个字符都有固定的位置，不能随意更改。
2. 从左到右：顺序字符串从左到右排列，先排列第一个字符，再排列第二个字符，以此类推。
3. 从上到下：顺序字符串从上到下排列，先排列第一行，再排列第二行，以此类推。
4. 长度可变：顺序字符串的长度可以变化，可以根据需要添加或删除字符。
5. 易于处理：顺序字符串易于处理，可以使用各种字符串处理函数进行操作，如查找、插入、删除等。

总之，顺序字符串是一种简单、直观、易于处理的字符串表示方式，广泛应用于各种编程语言和数据处理中。

参考文献

1. 李刚 刘万辉. "线性表的结构分析和应用." 9787040461473: 16. 2017.1.1
2. 文心一言