详解字符串

一、串的基本概念

数据结构中的串（String）是由零个或多个字符组成的有限序列。它是一种线性结构，可以使用顺序存储或链式存储来表示。串在计算机科学中广泛应用于文本处理、字符串匹配、密码学等领域。
 

1、定义

串是由零个或多个字符组成的有限序列，其中字符的个数称为串的长度。可以用S[0]、S[1]、…、S[n-1]表示串S的每个字符，其中n是串的长度。串中的字符可以是任意类型，如字母、数字、特殊字符等。

2、优缺点

优点

灵活性：串可以表示不同类型的数据，如文本、数据库记录等。它在文本处理、搜索、替换等方面具有灵活性和实用性。
支持字符串操作：串的定义和实现通常包括了一系列的字符串操作，如连接、比较、插入删除和复制等。这些操作使得对字符串的处理更加方便和高效。
应用广泛：串在计算机科学的多个领域有着广泛的应用，如文本编辑、编译器设计、数据压缩、密码学等。

缺点

存储空间浪费：串的存储通常需要额外的空间来存储字符，而且在实际使用中，可能会浪费一些存储空间。

操作复杂度：某些串操作的时间复杂度较高，例如字符串比较和模式匹配等操作，可能需要较长的时间来执行。

3、基本操作

初始化串：设置串的最大值，并初始化串的长度为零。。
求串长：输出两个串的长度
串的连接：将主串和子串合并成一个新串。
串的比较：比较两个串的大小关系。
模式匹配：在串中查找子串的位置。
拷贝：将指定字符常量复制到串结构体数据中。
插入：在主串指定位置之后插入一个新的字符串
删除：在主串指定位置开始删除指定几位字符

二、代码实现

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

/*串的插入*/ 
void insString(sstring* S, int pos, char* insertStr);

/*删除*/
int delString(sstring *S,int i,int j);

2、接口实现

2.1 初始化串

/*初始化串*/
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;
}

2.2 从字符常量拷贝

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

2.3 模式匹配

/*模式匹配*/
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;
}

2.4 串比较

/*串比较 */
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;
}

2.5 求串长

/*求串长*/
int slength(sstring* str) {
    return str->len;
}

2.6 串的拼接

/*串的拼接*/
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;
}

2.7 串的插入

/*串的插入*/
void insString(sstring* S, int pos, char* insertStr) {//代表往后移的字符串，pos代表指定位置，insertStr代表插入的值
    int insertLen = strlen(insertStr);

    //内存max溢出
    if (S->len + insertLen >= S->max) {
        printf("字符串的总长度将超过最大值！ 【10002】\n");
        return;
    }
    //位置合法判断
    if (pos< 1 || pos > S->len+1) {
        printf("插入位置不合法！【10003】\n");
        return;
    }
    
    // 移动后面的字符，给插入的子串让出位置
    for (int i = S->len; i >= pos; i--) {
        S->data[i + insertLen] = S->data[i];
    }
    
    // 插入子串
    for (int i = 0; i < insertLen; i++) {
        S->data[pos + i] = insertStr[i];
    }

    // 更新串的长度
    S->len = S->len + insertLen; 
}

2.8 串的删除

/*串的删除*/
int delString(sstring *S,int i,int j)//s代表字符串，i表示起始位置，j表示i之后多少个
{
    int k;
    //位置参数如果有误
    if(i<1||i>S->len||j<1||i+j>S->len+1)
    {
        return 0;
    }
    else{
        //将s的第i+j位置之后的往前移动j位
        for(k = i+j-1;k<S->len;k++)
        {
            S->data[k-j] =S->data[k];
        }
        //避免之前位置的值还在
        S->data[S->len-j]='\0';
        //修改s的长度
        S->len = S->len-j;
        return 1;
    }
}

2.9 main方法

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


char welcome[] = "\n//                          _ooOoo_                               //\n//                         o8888888o                              //\n//                         88”.“88                              //\n//                         (| ^_^ |)                              //\n//                          O\  =  /O                              //\n//                       ____/`---'\____                           //\n//                     .'  \\|     |//  `.                         //\n//                     /  \\|||  :  |||//  \                        //\n//                   /  _||||| -:- |||||-  \                       //\n//                    |   | \\\  -  /// |   |                       //\n//                    | \_|  ''\---/''  |   |                       //\n//                    \  .-\__  `-`  ___/-. /                       //\n//                 ___`. .'  /--.--\  `. . ___                     //\n//          .‘’ '<  `.___\_<|>_/___.'  >' ‘’.                  //\n//              | | :  `- \`.;`\ _ /`;.`/ - ` : | |                 //\n//                \  \ `-.   \_ __\ /__ _/   .-` /  /                 //\n//       ========`-.____`-.___\_____/___.-`____.-'========         //\n//                           `=---='                              //\n//      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        //\n//           佛祖保佑      永不宕机     永无BUG                   //\n\n";



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<10000;m++)
    for(n=0;n<100;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(" 10.删除\n");

    printf(" 11. 帮助\n");
    printf(" 0. 退出\n");
    printf(" 请选择（0~9）：");
    scanf("%d",&cmd);
    switch(cmd){
case 1:
    init(&S, 1000);
    init(&sub, 100);
    init(&t, 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("主串的长度为%d\n",slength(&S));
    printf("子串的长度为%d\n",slength(&sub));
break;
case 7:
    printf("主串打印：%s\n",S.data);
    printf("子串打印：%s\n",sub.data);
break;
case 8:
    strcat_sstring(&S, &sub);
    printf("主串和子串的拼接：%s\n",S.data);
break;
case 9:
	printf("输入插入主串的字符:");
	scanf("%s", str3);
	printf("输入插入的位置:");
	scanf("%d", &num);
	insString(&S,num,str3);
    printf("插入成功! 新的串为：");
    printf(S.data);
    printf("\n");
break;

case 10:
	printf("串的删除\n"); 
	printf("从第几位开始:");
	scanf("%d",&x);
	printf("删除几位:");
	scanf("%d",&y);
	delString(&S,x,y);
    printf("删除成功！\n");
break;
case 11:
    printf("本程序为顺序字符串的演示程序，由杜露设计开发\n\n");
break;

}

}while(cmd!=0);


return 0;
}

3、运行结果图

三、小结

串是由零个或多个字符组成的有限序列，它在计算机科学中具有广泛的应用。串的优点包括灵活性、支持字符串操作以及广泛的应用场景。然而，串的缺点包括存储空间浪费和某些操作的复杂度较高。在实际应用中，我们需要根据具体的需求和场景选择合适的串实现方式和算法。串的应用范围广泛，能够提升文本处理、字符串匹配、数据压缩和密码学等领域的效率和功能。

参考文献

百度百科，CSDN，数据结构（C语言版）