详解顺序字符串

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

运行结果

小结

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

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

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

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

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

参考文献

文心一言

相关推荐
小灰灰爱代码17 分钟前
C++——求3*3矩阵主对角元素之和。
c++·算法·矩阵
鱼跃鹰飞37 分钟前
Leetcode面试经典150题-94.二叉树的中序遍历
算法·leetcode·面试
Roam-G43 分钟前
Java 中常用的排序算法
数据结构·算法·排序算法
hjxxlsx1 小时前
插入与冒泡排序(C++)
c++·算法·排序算法
Skrrapper1 小时前
【数据结构】排序算法系列——快速排序（附源码+图解）
c语言·数据结构·算法·排序算法
Mephisto.java1 小时前
【力扣 | SQL题 | 每日三题】力扣175， 176， 181
sql·算法·leetcode
木向1 小时前
leetcode第十二题：整数转罗马数字
c++·算法·leetcode·职场和发展
繁星璀璨G1 小时前
C++11标准模板（STL）- 常用数学函数 - 计算e的给定幂 （ex）（std::exp, std::expf, std::expl）
开发语言·c++·算法·stl·计算e的给定幂
X² 编程说1 小时前
14.面试算法-字符串常见算法题（三）
java·数据结构·后端·算法·面试
S01d13r1 小时前
LeetCode 每周算法 6（图论、回溯）
算法·leetcode·图论
热门推荐
01CCF-CSP认证考试 202406-3 文本分词 100分题解02RAG 实践- Ollama+RagFlow 部署本地知识库032024年高教社杯数学建模国赛C题超详细解题思路分析04实战 | 基于YOLOv9和OpenCV实现车辆跟踪计数（步骤 + 源码）05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07【数据分享】1961—2022年全国范围的逐日降水栅格数据08苍穹外卖面试总结09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）