详解顺序字符串

最新推荐文章于 2024-11-06 22:08:19 发布
最新推荐文章于 2024-11-06 22:08:19 发布
阅读量135 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61704320/article/details/134220131
版权

顺序字符串的定义和特点

定义

顺序字符串是指字符串中的字符按照一定的顺序排列的字符串。具体而言，顺序字符串是由一系列按照某种规律排列的字符组成的字符串。这种规律可以是递增或递减的顺序，也可以是其他特定的规律。顺序字符串中的字符之间的间隔是相等的，即每个字符与其相邻的字符之间的距离是一样的。顺序字符串可以包含数字、字母或其他字符，但它们的顺序是有序的，不会改变字符的相对位置。顺序字符串可以进行比较和排序操作，因为字符的顺序是固定的。

特点

  1. 字符的顺序是固定的：顺序字符串中的字符按照一定的顺序排列，不会改变字符的相对位置。

  2. 字符的顺序是有规律的：顺序字符串中的字符按照一定的规律排列，可以是递增或递减的顺序，也可以是其他特定的规律。

  3. 字符之间的间隔是相等的：顺序字符串中的字符之间的间隔是相等的，即每个字符与其相邻的字符之间的距离是一样的。

  4. 可以进行比较和排序：由于顺序字符串中的字符有固定的顺序，可以进行比较和排序操作，例如可以使用比较运算符进行大小比较，也可以使用排序算法对顺序字符串进行排序。

总之，顺序字符串是一种具有固定顺序和规律排列的字符串，这种特点使得它可以进行比较和排序等操作。

顺序字符串的基本运算

  1. 拼接：将两个顺序字符串连接在一起，形成一个新的顺序字符串。例如，将"abc"和"def"拼接在一起，得到"abcdef"。

  2. 比较：比较两个顺序字符串的大小关系。可以使用比较运算符（如<、>、==）来比较两个顺序字符串的大小。比较的规则是按照字符的顺序进行比较。

  3. 子串提取：从一个顺序字符串中提取出指定的子串。可以通过指定起始位置和结束位置来提取子串。例如，从顺序字符串"abcdef"中提取出"bcd"。

  4. 查找：在一个顺序字符串中查找指定的字符或子串。可以使用查找算法（如线性查找、二分查找）来在顺序字符串中查找目标字符或子串。

  5. 替换：将顺序字符串中的某个字符或子串替换为指定的字符或子串。可以使用替换算法来实现替换操作。

  6. 切分：将一个顺序字符串按照指定的分隔符进行切分，得到多个子串。可以使用切分算法来实现切分操作。

这些基本运算可以帮助我们对顺序字符串进行各种操作和处理，以满足不同的需求。

顺序字符串的实现

定义：

typedef struct
{
	char* data;
	int max;
	int len;
}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;
}

从字符常量拷贝：

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

代码的运行截图：

完整Demo：

main.c

#include <stdio.h>
#include "sstring.c"
#include <string.h>
#include <stdlib.h>
#include "welcome.h"

int main(int argc, char* argv[])
{
	
	sstring S;
	sstring sub;
    sstring t;
	int index;
	char str1[100];
	char str2[100];
    char str3[100];
	int cmd,num,x,y;

	int result;
	int i = 0; 
	int m = 0; 
	int n = 0;
    for(i=0;i<strlen(welcome);i++)
	{
		printf("%c",welcome[i]);
		for(m=0;m<2000;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~8):");
		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

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

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

welcome.h

char welcome[] = "\n\
                               ............\n\                     
                            ................\n\                   
                           ..................\n\                  
                          ....................\n\                 
                          ....................\n\                 
                           ..................\n\                  
                       ....\ ............../\n\                   
   ...........      .........................\n\                  
 ..............\  /......../######\....../###\.\n\                
................v.........##########\...#######\n\               
..........................|######/..\##.|####/.\#|       ....\n\  
..................#####\.,|######....##.|####...#|     .......\n\ 
................|########.|######....##.|####...#|     .......\n\ 
...............#########_|######\../##.|####\./#|   /##\....\n\   
 ..............###############################nn\/#######^\n\     
   \........./ \########~##############nnnnn.###########/\n\      
                ########|##########nnnnn.##############/\n\       
                 #######| \###########################/\n\        
                  \###.##\    \######################\n\          
                    \##.##\   ___   \#############/\n\            
                       \.##\/.../..\         /##/\n\              
                          \##\/..../     /####/\n\                
                             \#############/\n\
                   Welcome to the mouse program\n\n";

小结

特点：
1. 字符的顺序是固定的，不会改变字符的相对位置。
2. 字符的顺序是有规律的，可以是递增或递减的顺序，也可以是其他特定的规律。
3. 字符之间的间隔是相等的，即每个字符与其相邻的字符之间的距离是一样的。
4. 可以进行比较和排序操作，由于字符的顺序是固定的。
基本运算：
1. 拼接：将两个顺序字符串连接在一起，形成一个新的顺序字符串。
2. 比较：比较两个顺序字符串的大小关系。
3. 子串提取：从一个顺序字符串中提取出指定的子串。
4. 查找：在一个顺序字符串中查找指定的字符或子串。
5. 替换：将顺序字符串中的某个字符或子串替换为指定的字符或子串。
6. 切分：将一个顺序字符串按照指定的分隔符进行切分，得到多个子串。
了解和掌握顺序字符串的特点和基本运算，可以帮助我们更好地处理和操作字符串数据，满足不同的需求。

参考文献

【1】李刚 刘万辉 “数据结构”（c语言）

【2】百度百科（百度文库）查询

小鼠Xs
关注
字符串加密算法详解.pdf
06-30
### 字符串加密算法详解 #### 一、引言 在信息安全领域，字符串加密是保护数据隐私和增强数据安全性的一种关键技术。随着网络攻击手段的不断进化，加密技术也在不断发展和完善。本文将详细介绍几种常见的字符串...
flutter开发小技巧以及注意点
一步一步的前进
04-14 421
16.接口,dart里面没有专门的抽象类,只能用普通类或抽象类当成接口使用，使用关键字来实现接口。在属性或方法名前面加_(下划线)
Python连接字符串过程详解
09-18
当两个或多个字符串通过加号连接时，它们会按照顺序拼接在一起形成一个新的字符串。例如： ```python result = "First" + "Python" + "Lesson" print(result) # 输出: FirstPythonLesson ``` 在上面的代码中，我们...
JavaScript实现反转字符串的方法详解
10-19
字符串反转是编程中常见的一种操作，其目的是将字符串中的字符顺序颠倒过来。在JavaScript中，字符串的反转可以通过组合使用几个内置函数来实现，这些函数包括join()、split()以及reverse()。 首先，让我们详细解读...
Python字符串格式化
09-21
当使用元组或列表传递实际值时，格式字符串中的每个占位符将按顺序与元组或列表中的相应元素匹配。 ```python print("I'm %s. I'm %d years old" % ('Vamei', 99)) ``` 在这个例子中，`%s`和`%d`分别表示字符串和...
详解C++ string字符串类
08-26
- 大于、小于、大于等于、小于等于操作符：用于进行字符串间的字典顺序比较。 在实际编程中，我们需要注意以下几点： - 在进行赋值操作时，如果内容改变或析构后，返回的字符串地址会不同，因为返回的字符串是通过...
开放寻址法、链式哈希数据结构详细解读
m0_61840987的博客
11-06 493
开放寻址法在低负载因子时效率较高，而链式哈希在高负载因子下表现更稳定。
数据结构，问题 F: 括弧匹配检验
nick_912912的博客
11-02 429
假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ]）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。匹配就输出 “OK” ，不匹配就输出“Wrong”。现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？输入仅一行字符（字符个数小于255）输入一个字符串：［（［］［］）］，输出：OK。
【数据结构】B树
藓类少女的博客
11-06 562
B树通常定义为一棵平衡的多路搜索树，并用一个整数 m 表示其阶数，即每个节点最多有 m 个子节点。每个节点最多包含 m - 1 个关键字和 m 个子节点。每个非根节点至少包含 ⌈m/2⌉−1 个关键字和 ⌈m/2⌉ 个子节点。根节点至少包含 1 个关键字，特殊情况除外（当树为空时，根节点没有关键字）。所有叶子节点都在同一层，即 B 树的高度是均匀的。每个节点的关键字从小到大排序，并且遵循左小右大的原则。每个关键字 k 的左子树的所有关键字都小于 k，右子树的所有关键字都大于 k。
算法中使用的数据结构解释*
qq_24428851的博客
11-03 650
***数据框架术****语****在这篇文章中，我们将研究在DataFrame背景下使用的一些术语。****作为一个组，多个轴被称为轴。*****选择列******行的选择*****让我们仔细看一下它们各自的情况。****列的选择：******[图片上传失败...(image-fae2e6-1667467474168)]******还有一个名为红色的集合，它包含红色的东西****这两个集合有一些共同的东西。******[图片上传失败...(image-b73e45-1667467474168)]****
数据结构第七章查找-树表的查找(二叉排序树的查找)
2305_78057683的博客
11-06 81
【代码】数据结构第七章查找-树表的查找(二叉排序树的查找)
数据结构-堆
wwwwwgery的博客
11-06 175
/存储元素的数组int Size;//堆当前元素的个数//堆的最大容量//最大堆//最小堆#define MAXDATA 1000//该值应根据具体情况定义为大于堆中所以可能元素的值//创建容量为MaxSize的空的最大堆return H;
数据结构(8.7_1)——外部排序
m0_65240792的博客
11-03 177
输出缓冲区1空了用归并段1的下一块元素补上 ..... 顺序的两个归并段方法一样..... 由于文件总块数无法改变，所以只能对归并趟数进行改变 注意：k不能无限增大、若k太大了也会增加内部归并所需时间在缓冲区内直接排序
数据结构 ——— 计算链式二叉树第k层的节点个数
weixin_55341642的博客
11-06 494
分治算法计算链式二叉树第 k 层的节点个数
题目练习之二叉树那些事儿
最新发布
2401_82924480的博客
11-06 658
二叉树题目练习
哈夫曼树和哈夫曼编码与译码
fcc13461862452的博客
11-06 275
本文介绍了与哈夫曼树与编码的一系列操作，包含Huffman树的创建，Huffman编码、Huffman译码，并带有完整C++代码实现。
《Java 实现选择排序：原理剖析与代码详解》
qq_69304031的博客
11-03 479
选择排序作为一种简单直观的排序算法，虽然在效率上可能不如一些更高级的排序算法，但它是理解排序概念的一个很好的入门选择。选择排序的基本思想是：在未排序的序列中找到最小（或最大）的元素，然后将其与未排序序列的第一个元素进行交换位置。接着，在剩余的未排序序列中继续寻找最小（或最大）元素，并与未排序序列的第二个元素进行交换，以此类推，直到整个序列都被排序完成。简单来说，每一轮排序都能确定一个元素在最终有序序列中的位置，经过多次这样的轮次，就能将整个数组排序好。，这样就能准确找到这一轮未排序序列中的最小值及其下标。
线性数据结构
Amsssssssssss的博客
11-02 286
线性数据结构是一种数据元素之间存在一对一关系的数据结构。这意味着每个数据元素（除了第一个和最后一个）都有一个前驱和一个后继。这种结构可以用物理或逻辑上的线性方式来表示元素之间的顺序。
【数据结构】尾指针（Tail Pointer）详解
XuanRan的博客
11-02 1755
在数据结构的实现中，链表作为一种基本的线性结构广泛应用于计算机科学和软件工程中。链表的灵活性和动态性使其成为许多算法的基础，而尾指针则是提升链表操作效率的重要工具。本文将详细探讨尾指针的定义、作用、实现方式、使用场景以及其在实际应用中的示例。
Java字符串处理详解
- `compareTo()`和`compareToIgnoreCase()`用于按字典顺序比较字符串。 理解这些基本的`String`类方法对于开发中处理文本数据非常关键。在实际编程中，根据需求选择适当的方法进行字符串的比较、查找、截取等操作，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值