详解顺序字符串

最新推荐文章于 2024-05-31 14:19:08 发布

m0_72158882

最新推荐文章于 2024-05-31 14:19:08 发布

阅读量73

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/m0_72158882/article/details/134221194

版权

定义

顺序字符串是一种数据结构，它由一组连续的存储单元组成，每个存储单元存储一个字符。顺序字符串中的字符按照一定的顺序排列，不能随意更改或打乱顺序。在计算机编程中，顺序字符串具有重要的作用，例如它们可以表示文本、文件路径、网络地址等各种信息。顺序字符串的长度可以通过计算字符数量来获取，也可以使用特定的长度属性来获取。

特点

顺序性：顺序字符串中的字符按照一定顺序排列，每个字符的位置都是确定的。
有限长度：顺序字符串的长度是有限的，即字符串中字符的个数有限。
字符集：顺序字符串由特定的字符集合组成，字符集可以是字母、数字、符号等。
可比较性：由于顺序字符串的顺序性，可以对其进行比较操作，确定字符串的大小关系。
可索引性：由于顺序字符串中字符的确定位置，可以通过索引访问、修改字符串中的某个字符。

基本运算

字符串连接：将两个字符串连接起来，形成一个新的字符串。
子串提取：从字符串中提取出某个子串，可以指定起始位置和提取长度。
子串替换：将字符串中的某个子串替换为另一个字符串，生成一个新的字符串。
字符串比较：比较两个字符串的大小关系，可以判断它们是否相等、哪个更大或哪个更小。
字符串长度：获取字符串的长度，即其中包含的字符数。
字符串插入：在指定位置插入一个字符串，生成一个新的字符串。
字符串删除：从字符串中删除指定位置的字符，生成一个新的字符串。
字符串查找：在字符串中查找另一个子串的位置，如果找到则返回其起始位置，否则返回-1。

代码实现

1.定义接口


/*
	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.初始化

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

3.从字符常量拷贝


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

4.模式匹配


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

5.串比较

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

6.串长

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

7.串的拼接

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;
 
	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~9）：");
		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("本程序由YYH开发演示顺序字符串\n");
		    break;
		}
		
	}while(cmd!=0);
	
 
	return 0;
}

sstring.c


/*
	sstring.c
 
*/
#include "sstring.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.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


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

运行截图

小结

顺序字符串是一种由一组字符或符号按照一定顺序排列组成的字符串。

顺序字符串的基本运算包括字符串连接、子串提取、子串替换、字符串比较、字符串长度、字符串插入、字符串删除、字符串查找以及字符串翻转等。这些基本运算可以实现对顺序字符串的操作和处理。

顺序字符串在计算机科学和数据处理中扮演着重要的角色，例如表示文本、文件路径、网络地址等各种信息。

m0_72158882

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
详解顺序字符串

顺序字符串是一种数据结构，它由一组连续的存储单元组成，每个存储单元存储一个字符。顺序字符串中的字符按照一定的顺序排列，不能随意更改或打乱顺序。在计算机编程中，顺序字符串具有重要的作用，例如它们可以表示文本、文件路径、网络地址等各种信息。顺序字符串的长度可以通过计算字符数量来获取，也可以使用特定的长度属性来获取。
复制链接

扫一扫