详解顺序字符串（C语言版）

k2865155467

于 2023-11-02 18:19:52 发布

阅读量298

点赞数

文章标签：数据库前端 c语言

本文链接：https://blog.csdn.net/k2865155467/article/details/134179185

版权

1.顺序字符串定义及特点：

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

2.有限长度：顺序字符串的长度是有限的，即字符串中字符的个数有限。

3…字符集：顺序字符串由特定的字符集合组成，字符集可以是字母、数字、符号等。

4.可比较性：由于顺序字符串的顺序性，可以对其进行比较操作，确定字符串的大小关系。

5.可索引性：由于顺序字符串中字符的确定位置，可以通过索引访问、修改字符串中的某个字符。

需要注意的是，顺序字符串与无序字符串（如集合）不同，顺序字符串中每个字符的位置都是固定的，而无序字符串中元素的位置没有固定顺序。

2.基本运算：

顺序字符串支持一些基本的运算操作，包括：

1.拼接（Concatenation）：将两个顺序字符串连接在一起，形成一个新的顺序字符串。通常使用"+"符号表示，例如：str1 + str2。

2.长度（Length）：计算顺序字符串中的字符个数，即字符串的长度。通常使用len()函数获取字符串的长度，例如：len(str)。

3.索引（Indexing）：通过索引访问顺序字符串中的特定字符。索引从0开始，正向索引表示从左往右的位置，反向索引表示从右往左的位置。例如：str[index]，其中index是要访问的字符的索引。

4.切片（Slicing）：获取顺序字符串中的一个子串，通过指定开始和结束位置的索引进行切片。切片操作使用[start:end]的形式，含义是从start索引（包括）到end索引（不包括）之间的子串。例如：str[start:end]。

5.比较运算（Comparison）：可以对两个顺序字符串进行比较运算，判断它们的大小关系。比较运算符包括等于（==）、不等于（!=）、小于（<）、大于（>）、小于等于（<=）和大于等于（>=）等。

6.查找（Find）：在顺序字符串中查找指定子串的位置。常见的方法是使用find()函数或index()函数，它们返回子串在字符串中的起始位置，如果找不到则返回-1。例如：str.find(substring)或str.index(substring)。

7.替换（Replace）：将顺序字符串中的指定子串替换为新的字符串。可以使用replace()函数完成替换操作，例如：str.replace(old, new)。

总之，还有其他的运算，这里我不过多讲解了，需要的自己查找。需要根据具体的编程语言和环境来使用相应的语法和函数来执行这些基本运算。

3.代码实现过程：

定义的结构体类型为 sstring

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

定义一个 init 的函数，用于初始化 sstring 结构体变量

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 的函数，用于将字符常量拷贝到 sstring 结构体中

/*从字符常量拷贝*/
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;
}

定义一个名为 sstrmatch 的函数，用于在 sstring 结构体中查找子字符串

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;
}

定义一个名为 sstring_compare 的函数，用于比较两个 sstring 结构体表示的字符串的大小。

//串比较
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;
}

定义一个名为 slength 的函数，用于获取 sstring 结构体表示的字符串的长度

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

定义一个名为 strcat_sstring 的函数，用于将两个 sstring 结构体表示的字符串进行拼接

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;
}

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);

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;
}

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;



	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;
}

运行结果
在这里插入图片描述

4.小结

总的来说，顺序字符串是一种简单且高效的表示字符串的数据结构，适用于处理相对较小的字符串。但在面对大量或者动态变化的字符串时，更灵活的数据结构如动态字符串可能更为合适。值得学习！谢谢老师的教学。

5.参考文献

1.百度
2. 李刚刘万辉数据结构（C语言版）
3. 老师上课的代码

k2865155467

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
详解顺序字符串（C语言版）

顺序字符串是由零个或多个字符组成的有限序列，一般记作：S=“a1a2a3…an”。其中，S是串名，用双引号括起来的字符序列是串的值，ai(1≤i≤n)可以是字母、数字或其他字符，n是串的长度。当n=0时，S为空串（null string）。串中任意一个连续的字符组成的子序列称为该字符的子串。相应的包含子串的串称为主串。通常将字符在串中的序号称为该字符在串中的位置。它的特点如下：1.顺序性：顺序字符串中的字符按照一定顺序排列，每个字符的位置都是确定的。
复制链接

扫一扫