详解顺序字符串

用户47804373991182023-11-01 10:42

详解顺序字符串

定义

顺序串是一种线性数据结构，采用顺序存储方式。它的元素按照顺序排列。顺序串在内存中以连续的方式存储，具有随机访问和插入、删除操作方便等优点。

特点

顺序串的特点主要有：

  1. 元素之间连续存储：顺序串的元素是连续存储的，这使得元素的访问和读取变得更为高效。
  2. 随机访问：由于元素的连续存储，我们可以直接通过索引来访问顺序串中的任意元素，而不需要进行任何的查找操作。
  3. 空间利用率可能较低：顺序串需要预先分配一定的存储空间，即使这些空间并未完全被使用，也会导致空间的浪费。

请注意，这些特点可能会根据具体的使用情况和需求有所不同。

顺序字符串的运算

初始化

这段代码是一个函数，用于初始化一个顺序串。它首先为顺序串的data成员分配内存空间，如果内存分配失败，则输出错误信息并返回一个特定值。然后，它将最大长度和当前长度设置为参数中指定的值。

c 复制代码 
/*初始化串*/
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;
}

从字符常量拷贝到字符串

这段代码是一个函数，用于将一个字符常量拷贝到一个字符串中。以下是代码的简单解释：

  1. 函数名为sstrcpy，接受两个参数：一个字符串指针S和一个字符指针from。
  2. 计算from字符串的长度，并存储在变量len中。
  3. 检查len是否超过S指向的字符串的最大长度。如果超过，输出错误信息并返回特定值。
  4. 使用循环，逐个将from字符串中的字符拷贝到S指向的字符串中。
  5. 在S指向的字符串的末尾添加空字符（'\0'），表示字符串结束。
  6. 将拷贝的字符串长度存储在S指向的字符串的len成员中。
  7. 函数返回0，表示拷贝操作成功完成。
c 复制代码 
/*从字符常量拷贝到字符串*/
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）的长度，分别存储在变量m和n中。

然后，函数通过一个循环遍历主字符串。这个循环的索引i从0开始，直到主字符串的长度减去子字符串的长度（m-n）。这是为了确保主字符串中的每个可能的子字符串都被检查。

在循环的每次迭代中，函数使用另一个循环来检查主字符串的一个子串是否与给定的子字符串匹配。这个内循环从索引j=0开始，并在遇到不匹配的字符或到达子字符串的末尾时停止。

如果子串与子字符串完全匹配（即，j==n），则函数返回当前索引i。这是子字符串在主字符串中首次出现的位置。

如果循环遍历了整个主字符串都没有找到匹配的子字符串，则函数返回-1。

c 复制代码 
/*模式匹配*/
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;
}

串比较

这是一个比较两个顺序串的C语言函数。如果第一个串的长度小于第二个串，返回-1；如果长度大于第二个串，返回1；如果长度相等，则逐个字符比较，如果有不等字符或长度相等，则返回结果。如果两个串完全相等，返回0。

c 复制代码 
//串比较
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;
}

串长

函数返回sstring的len成员，即字符串的长度。

c 复制代码 
//串长
int slength(sstring* str) {
    return str->len;
}

串的拼接

如果两个字符串拼接后的长度超过了第一个字符串的最大长度，它会使第一个字符串的内存空间扩大以容纳两个字符串。然后，它会将第二个字符串添加到第一个字符串的末尾，并更新第一个字符串的长度。这个函数可以用于需要拼接两个字符串的任何情况。

c 复制代码 
//串的拼接
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;
}

串的实现

完整代码

项目结构

css 复制代码 
main.c
sstring.c
sstring.h

项目文件

main.c

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;
	int i = 0; 
	int m = 0; 
	int n = 0;

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

sstring.c

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

sstring.h

c 复制代码 
/*
	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);

运行结果

小结

顺序串（也称为线性串）是使用一组地址连续的存储单元来存储字符序列的一种数据结构。它通常使用数组来实现，而数组中的每个元素都是一个字符。

顺序串的特点是可以通过下标直接访问任意位置的元素，这使得对串的操作非常方便。顺序串的长度可以通过计算数组中元素的个数得到，也可以在定义数组时预先设定一个最大长度，并通过一个额外的变量来存储当前串的长度。

在顺序串中，字符的存储是连续的，这使得它具有较好的空间利用率。同时，由于串的顺序存储结构与数组类似，因此我们可以使用类似于数组的方式来操作串，例如可以使用下标来访问和修改串中的字符。

顺序串的顺序存储结构在某些操作上比链式存储结构更为高效，例如在查找子串或替换子串等操作中，顺序存储结构可以直接通过下标访问元素，而链式存储结构则需要遍历链表。然而，链式存储结构在插入和删除元素时具有更好的性能，因为它不需要移动大量的元素。

总之，顺序串是一种常用的数据结构，适用于需要频繁访问和修改串中元素的操作。它的顺序存储结构和链式存储结构各有优缺点，选择哪种存储结构取决于具体的应用场景和需求。

参考文献

文心一言

相关推荐
邂逅岁月7 分钟前
滑不动窗口的秘密—— “滑动窗口“算法 (Java版)
算法·面试·求职招聘·创业创新·刷题
sunny-ll12 分钟前
【C++】explicit关键字详解（explicit关键字是什么? 为什么需要explicit关键字? 如何使用explicit 关键字）
c语言·开发语言·c++·算法·面试
轩源源16 分钟前
C++草原三剑客之一：继承
开发语言·数据结构·c++·算法·青少年编程·继承·组合
半盏茶香3 小时前
C语言勘破之路-最终篇 —— 预处理(下)
c语言·开发语言·c++·算法
pianmian17 小时前
贪心算法.
算法·贪心算法
chenziang18 小时前
leetcode hot 100 二叉搜索
数据结构·算法·leetcode
single5949 小时前
【c++笔试强训】（第四十五篇）
java·开发语言·数据结构·c++·算法
呆头鹅AI工作室10 小时前
基于特征工程（pca分析）、小波去噪以及数据增强，同时采用基于注意力机制的BiLSTM、随机森林、ARIMA模型进行序列数据预测
人工智能·深度学习·神经网络·算法·随机森林·回归
一勺汤11 小时前
YOLO11改进-注意力-引入自调制特征聚合模块SMFA
人工智能·深度学习·算法·yolo·目标检测·计算机视觉·目标跟踪
每天写点bug11 小时前
【golang】map遍历注意事项
开发语言·算法·golang
热门推荐
01docker安装启动问题解决排查02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）03玄机平台应急响应—webshell查杀04Gitlab ci/cd05【一文读懂】NTN（非地面网络）技术介绍06HCIA-datacom数通题库和录播视频资料07新手学习VR全景需要知道的几个问题08RAG 实践- Ollama+RagFlow 部署本地知识库09优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间10分布式训练原理总结（DP、PP、TP 、ZeRO）