五、《详解顺序串》

于 2023-11-01 11:37:24 发布
阅读量198 收藏
点赞数
文章标签： java 前端 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61786342/article/details/134156948
版权

目录

一、顺序串的定义

二、顺序串的运算

三、顺序串的实现

四、完整代码

1.main.c

2.sstring.c

3.sstring.h

4.welcome.h

五、运行结果截图

​编辑​编辑​编辑六、总结

七、参考文献

一、顺序串的定义

串是有零个或或多个字符组成的有限序列，又称为字符串。
一般记为：str="a1a2.....an-1*an"（n为正整数），str中串名，ai(1<=i<=n),由字母、数字和其他字符组成，n为串的长度。
串：由零个或多个字符组成的有限序列。 
    串也有两种储存方式，顺序储存和链式储存 
    1.顺序表示的串——顺序串
        一般使用字符型数组储存，确定串的长度有两种方法。一是：在串的末尾加一个结束标记（在C语言中系统自动在串值的末尾加一个'\0'作为结束标记 ），再使用 strlen函数得到串的长度。二是：增加一个变量 len 用来储存串的长度

二、顺序串的运算

  1. 连接运算：将两个顺序串连接起来，生成一个新的顺序串。
  2. 插入运算：在一个顺序串中插入另一个顺序串，生成一个新的顺序串。
  3. 删除运算：从一个顺序串中删除另一个顺序串，生成一个新的顺序串。
  4. 替换运算：在一个顺序串中替换另一个顺序串，生成一个新的顺序串。
  5. 翻转运算：将一个顺序串翻转过来，生成一个新的顺序串。
  6. 拷贝运算：将一个顺序串拷贝到另一个顺序串中，生成一个新的顺序串。


三、顺序串的实现

1、顺序字符串的定义

/*顺序字符串的定义*/
typedef struct
{
    char* data;
    int max;
    int len;
}sstring;

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

四、完整代码


1.main.c

#include <stdio.h>
#include "sstring.h"
#include <string.h>
#include "welcome.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;
    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");

    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");
            break;
        }
        
    }while(cmd!=0);
    

    return 0;
}
 

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

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

4.welcome.h

char welcome[]=(
    "         lovelove                   lovelove\n"
    "       lovelovelove               lovelovelove\n"
    "     lovelovelovelove           lovelovelovelove\n"
    "   lovelovelovelovelove       lovelovelovelovelove\n"
    "  lovelovelovelovelovelo     lovelovelovelovelovele\n"
    " lovelovelovelovelovelovelolovelovelovelovelovelovee\n"
    "  lovelovelovelovelovelolovellovelovelovelovelovele\n"
    "   lovelovelovelovelovelovelolovelovelovelovelove\n"
    "     lovelovelovelovelovelovelovloveloveloveloe\n"
    "       lovelovelovelovelovelovelovloveloveloe\n"
    "         lovelovelovelovelolovelovelloveloe\n"
    "           lovelovelovelovelovelovelovele\n"
    "             lovelovelovelovelovelocele\n"
    "               lovelovelovelovelovele\n"
    "                 lovelovelovelovele\n"
    "                   loveloveloveve\n"
    "                     lovelovelo\n"
    "                       lovelov\n"
    "                         love\n"
    "                          爱\n"

    );
 

五、运行结果截图


六、总结

顺序字符串是一种采用顺序存储结构的字符串数据结构，它按照字符在串中出现的顺序，以数组方式存储在计算机的连续内存空间中。每个字符占用一个字节，并且每个字符在串中都有一个固定的位置。

顺序字符串具有以下优点：

  1. 简单、直观、易于实现。
  2. 可以随机访问任何一个字符。
  3. 可以进行高效的字符串匹配等操作。

顺序字符串也存在一些缺点：

  1. 长度固定，不能动态增长或缩小，需要重新创建一个新的字符串来改变字符串的长度。
  2. 占用空间较大，如果需要存储大量的字符串，需要考虑如何节省空间。

七、参考文献


数据结构c语言版本（李刚）
百度查询
csdn博客

一万里晴空60
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值