数据结构 - 字符串

已于 2023-11-05 12:06:22 修改
阅读量543 收藏
点赞数
文章标签： 数据结构
于 2023-11-05 11:51:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52952392/article/details/134226220
版权

一. 字符串的定义

      字符串是一个由字符组成的有序序列。字符可以是字母、数字、标点符号或任何可打印的字符。字符串通常用于表示文本或文本数据。

二. 字符串的概念

      关于数据结构中串的一些概念：

  1. 串的长度：串的长度是指串中包含字符的数量，通常以字符数（或代码单元数）来衡量。长度为零的串是空串。

  2. 串的字符集：每个串都有一个字符集，这是可以包含在串中的字符的集合。不同的编程语言和编码系统支持不同的字符集，例如ASCII、Unicode等。

  3. 串的索引：每个字符在串中都有一个唯一的位置，可以通过索引来访问。通常，索引从0开始，依次增加。

  4. 串的特性：串通常是不可变的，这意味着一旦创建，它们的内容不可更改。如果需要修改串的内容，通常会创建一个新的串。

  5. 串的操作：串支持各种操作，包括连接、比较、切片、查找、替换、大小写转换、格式化等操作。这些操作允许对串进行处理、操作和转换。

  6. 字符串编码：串可以使用不同的字符编码来表示，以将字符映射为二进制数据。常见的字符编码包括UTF-8、UTF-16、ASCII等。

  7. 字符串的应用：串在编程中广泛应用，用于处理文本数据、用户界面、文件操作、网络通信等各种任务。它们也用于数据存储和传输。

三. 字符串的实现

（1）字符串初始化

/*初始化串*/
int init(sstring *S, int max) {
    S->data = (char *) malloc(sizeof(char) * max);

    if (!S->data) {
        printf("申请内存失败！1000\n");
        return 1000;
    }
    S->max = max;
    S->len = 0;
    return 0;
}

运行结果：

（2）从字符常量拷贝

/*从字符常量拷贝*/
int sstrcpy(sstring *S, char *str) {
    int i;
    int fromLength = getLength(str);

    if (fromLength > S->max) {
        printf("超出了字符串S的长度！1001\n");
        return 1001;
    }
    for (i = 0; i < fromLength; i++) {
        S->data[i] = str[i];
    }
    S->data[i] = '\0';
    S->len = fromLength;
    return 0;
}

运行结果：

   

 （3）模式匹配

/*模式匹配*/
int sstrmatch(sstring *S, const char *str) {
    int i, j, k;
    int m = S->len;
    int n = getLength(str);

    for (i = 0; i <= m - n; i++) {
        j = 0;
        k = i;
        while (j < n && S->data[k] == str[j]) {
            j++;
            k++;
        }
        if (j == n) {
            return i+1;
        }
    }
    return -1;
}

运行结果：

（4） 比较字符串大小

/*比较字符串大小*/
void comparison(sstring *S, sstring *str) {
    int sLength = getLength(S->data);
    int strLength = getLength(str->data);
    if (sLength == strLength) {
        int i;
        for (i = 0; i < S->len;) {
            int sAscll = (int) S->data[i];
            int strAscll = (int) str->data[i];
            if (sAscll == strAscll) {
                i++;
            } else if (sAscll > strAscll) {
                printf("%s比%s大\n", S->data, str->data);
                break;
            } else {
                printf("%s比%s大\n", str->data, S->data);
                break;
            }
        }
        if(i == S->len){
            printf("两个字符串相等\n");
        }
    } else if (sLength > strLength) {
        printf("%s比%s大：\n", S->data, str->data);
    } else {
        printf("%s比%s大：\n", str->data, S->data);
    }
}

运行结果：

（5）获取串的长度

/*获取串的长度*/
int getLength(const char *str) {
    int length = 0;
    while (str[length] != '\0'){
        length++;
    }
    return length;
}

 运行结果：

（6）追加字符串

/*追加字符串*/
void addSstring(sstring *S, const char from[]) {

    int fromLength = getLength(from);

    for (int i = 0; i < fromLength; ++i) {
        S->data[S->len + i] = from[i];
    }
    S->data[S->len + fromLength] = '\0';
    S->len += fromLength;
}

 运行结果：

（7）输出串

/*输出串*/
void printfS(sstring *S) {
    printf("%s\n", S->data);
}

运行结果：

四. 完整的Demo

1. main.c

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


int main() {

    sstring S, str;
    int cmd, max, index;

    str.data = malloc(100);


    for (int i = 0; i < getLength(welcome); i++) {
        printf("%c", welcome[i]);
        for (int m = 0; m < 1000; m++)
            for (int n = 0; n < 1000; 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");

        scanf("%d", &cmd);

        switch (cmd) {
            case 1:
                printf("请输入串的最大存储值：\n");
                scanf("%d", &max);
                fflush(stdin);
                if (!init(&S, max)) {
                    printf("初始化串成功！\n");
                } else {
                    printf("初始化串失败！\n");
                }
                break;
            case 2:
                printf("请输入拷贝的串：\n");

                fflush(stdin); // 清除输入缓冲区中的换行符

                scanf(" %[^\n]", str.data); // 加上空格，以消耗掉换行符

                if (!sstrcpy(&S, str.data)) {
                    printf("拷贝成功！\n");
                } else {
                    printf("拷贝失败！\n");
                }
                break;
            case 3:
                printf("请输入子串：\n");
                scanf(" %[^\n]", str.data);
                fflush(stdin);
                index = sstrmatch(&S, str.data);
                if (index != -1) {
                    printf("匹配成功，子串在主串的%d位置！\n", index);
                } else {
                    printf("主串中不存在子串：%s\n", str.data);
                }
                break;
            case 4:
                printf("请输入比较大小的字符串：");
                scanf(" %[^\n]", str.data);
                fflush(stdin);
                comparison(&S, &str);
                break;
            case 5:
                printf("字符串长度：%d\n", getLength(S.data));
                break;
            case 6:
                printf("请输入追加的字符串：\n");
                scanf(" %[^\n]", str.data);
                fflush(stdin);
                addSstring(&S, str.data);
                printf("追加成功！\n");
                break;
            case 7:
                printfS(&S);
                break;
            case 0:
                printf("感谢使用！\n");
                break;
            default:
                printf("输入有误！请重新输入\n");
                break;
        }
    } while (cmd != 0);

    free(S.data);
    free(str.data);

    return 0;
}

2. sstring.c 

/*
	sstring.c

*/
#include <stdio.h>
#include "sstring.h"
#include <stdlib.h>


/*初始化串*/
int init(sstring *S, int max) {
    S->data = (char *) malloc(sizeof(char) * max);

    if (!S->data) {
        printf("申请内存失败！1000\n");
        return 1000;
    }
    S->max = max;
    S->len = 0;
    return 0;
}

/*从字符常量拷贝*/
int sstrcpy(sstring *S, char *str) {
    int i;
    int fromLength = getLength(str);

    if (fromLength > S->max) {
        printf("超出了字符串S的长度！1001\n");
        return 1001;
    }
    for (i = 0; i < fromLength; i++) {
        S->data[i] = str[i];
    }
    S->data[i] = '\0';
    S->len = fromLength;
    return 0;
}


/*模式匹配*/
int sstrmatch(sstring *S, const char *str) {
    int i, j, k;
    int m = S->len;
    int n = getLength(str);

    for (i = 0; i <= m - n; i++) {
        j = 0;
        k = i;
        while (j < n && S->data[k] == str[j]) {
            j++;
            k++;
        }
        if (j == n) {
            return i+1;
        }
    }
    return -1;
}

/*比较字符串大小*/
void comparison(sstring *S, sstring *str) {
    int sLength = getLength(S->data);
    int strLength = getLength(str->data);
    if (sLength == strLength) {
        int i;
        for (i = 0; i < S->len;) {
            int sAscll = (int) S->data[i];
            int strAscll = (int) str->data[i];
            if (sAscll == strAscll) {
                i++;
            } else if (sAscll > strAscll) {
                printf("%s比%s大\n", S->data, str->data);
                break;
            } else {
                printf("%s比%s大\n", str->data, S->data);
                break;
            }
        }
        if(i == S->len){
            printf("两个字符串相等\n");
        }
    } else if (sLength > strLength) {
        printf("%s比%s大：\n", S->data, str->data);
    } else {
        printf("%s比%s大：\n", str->data, S->data);
    }
}

/*获取串的长度*/
int getLength(const char *str) {
    int length = 0;
    while (str[length] != '\0'){
        length++;
    }
    return length;
}

/*追加字符串*/
void addSstring(sstring *S, const char from[]) {

    int fromLength = getLength(from);

    for (int i = 0; i < fromLength; ++i) {
        S->data[S->len + i] = from[i];
    }
    S->data[S->len + fromLength] = '\0';
    S->len += fromLength;
}

/*输出串*/
void printfS(sstring *S) {
    printf("%s\n", S->data);
}

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

/*模式匹配*/
int sstrmatch(sstring *S, const char *str);

/*比较字符串大小*/
void comparison(sstring *S, sstring *str);

/*字符串长度*/
int getLength(const char *str);

/*追加*/
void addSstring(sstring *S, const char *from);

/*输出字符串*/
void printfS(sstring *S);

 五. 总结

       字符串是编程中非常常见和重要的数据结构，用于处理文本、用户输入、文件操作、数据交换等各种任务。许多编程语言都提供了丰富的字符串处理函数和方法，以简化对字符串的操作。总之，字符串是一种用于表示文本数据的数据结构，具有一些特定的特性和操作。在编程中，对字符串的有效操作和处理是非常关键的，因为字符串在许多应用中都起着重要的作用。

六. 参考文献

1.百度一下

2.C语言数据结构

weixin_52952392
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
c语言 数据结构实现之字符串
08-30
C语言数据结构实现之字符串 C语言数据结构实现之字符串是指使用C语言来实现字符串数据结构的相关操作。字符串是一种基本的数据结构，广泛应用于计算机科学和信息技术领域。下面将详细介绍C语言数据结构实现之字符串...
C 语言 —— 字符串
柚咖小窝
06-08 3435
什么是字符串？   定义： 字符串是以空字符(\0)结尾的字符(char)数组。   字符串是一种特殊的字符数组，特殊在字符串是以空字符 ‘\0’ 结尾上，这样只需要给出字符串的起始地址，编译器就可以知道字符串的范围是从起始地址到空字符，不需要我们再指出数组长度，或者结束地址了。   因为字符串是一种字符数组，因此数组和指针的知识都可以运用到字符串上。但是字符串实在是太常用了，因此 C 提供了很多用于处理字符串的函数，这些函数基本都是需要掌握的，因为这些函数都是可以大大提高我们处理字符串的效率。 字符串
Java学习：字符串概述与特点
weixin_30394333的博客
06-28 127
字符串概述与特点 java.lang.String类 代表字符串 API当中说：Java程序中的所有字符串字面值（如“abc“）都作为此类的实例实现。其实就是说：程序当中所用的双引号字符串，都是String类的对象。（就算没有new，也照样是。） 字符串的特点 字符串的内容永远不可改变。【重点】 正是因为字符串不可改变，所以字符串是可以共享使用的。 字符串效果上相...
字符串的特性
qq_21843251的博客
02-10 2497
1.void  修饰  : 函数的返回值类型  ：函数不需要像调用者返回状态的情况下使用 函数形参列表      ：不需要往函数内部闯入实参的时候 修饰指针 用void修饰的指针称为万能指针（所有类型的指针中兼容性最强的指针） 字符串特性： 1，字符串的内部原理就是一个所谓的只读型字符型数组 2，字符串是一种特殊类型，而且这个数组是只读的，不能够通过指针更改字
JAVA字符串特点
xvjixiang的专栏
03-31 689
1、java提供一个字符串池保存字符串，使用共享设计； 2、字符串内容不可改变
字符串的定义，特点
热门推荐
weixin_52485836的博客
11-30 2万+
字符串的定义，特点
字符串String的特点及方法
zhansan的博客
11-24 569
特点 1.字符串不变：字符串的值在创建后不能被更改。 String s1 = "abc"; s1 += "d"; System.out.println(s1); // "abcd" // 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。 2.因为String对象是不可变的，所以它们可以被共享。 String s1 = "abc"; String s2 = "abc"; // 内存中只有一个"abc"对象被创建，同时被s1和s2共享。 3."abc" 等效
数据结构-字符串.pptx
07-11
字符串 数据结构-字符串全文共87页，当前为第1页。 字符串 字符串的范畴非常广泛； 难题往往在此节出现； 掌握字符串的法门是 。 字符串问题的晦涩代表：KMP、Manacher 数据结构-字符串全文共87页，当前为第2页。 ...
数据结构-字符串.pdf
07-11
数据结构_字符串 字符串 堆的动态分配 //堆 动态分配 //realloc函数⽤于修改⼀个原先已经分配的内存块的⼤⼩，可以使⼀块内存的扩⼤或缩⼩。 //void *realloc (void *ptr, size_t new_size ); #include <iostream> #...
数据结构-字符串-课程设计.doc
06-13
《数据结构》课程设计主要关注的是字符串操作，其中包括文章编辑的各种功能。设计的程序通过使用线性表（链表和数组）作为存储结构，实现了以下几个关键模块： 1. **英文字母、数字、空格及文章总字数统计模块**： ...
头歌数据结构数据结构—字符串
05-18
头歌数据结构数据结构—字符串 第1关子串插入 第2关子串删除 第3关子串定位 第4关子串替换 稳过 早期的计算机主要是用做科学和工程方面的计算。后来随着计算机的发展，非数值型数据的处理工作越来越多，于是有了...
【Java】字符串String的特点
渐若窥宏大的博客
05-23 1603
String字符串 java.lang.String 1、字符串的特点 1、字符串String类型本身是final声明的，意味着我们不能继承String。final类不能被继承。 2、字符串的对象也是不可变对象，意味着一旦进行修改，就会产生新对象 字符串的对象也是不可变对象 我们修改了字符串后，如果想要获得新的内容，必须重新接受。 如果程序中涉及到大量的字符串的修改操作，那么此时的时空（时间、空间 ）消耗比较高。可能需要考虑使用StringBuilder或StringBuffer。 3、String对象
String字符串的特点 ---- 常见面试题 (详解)
qq_41656046的博客
07-16 136
String字符串的特点: 1. Java程序中所有的双引号字符串,都是String类的对象 2. 字符串不可变,他们的值在创建后不能够被更改 3. 虽然String的值是不可变的,但是他们可以被共享 注意: 这里所说的共享指的是字符串常量池. 字符串常量池:当使用双引号创建字符串对象的时候,系统会检查该字符串是否在字符串常量池中存在 存在 : 不会创建,而是直接复用 不存在:创建 Str...
string的特点
dapaogez1的博客
07-16 157
public static void main(String[] args) { /* 字符串的特点 字符串不可变，它们的值在创建后不能被更改 虽然String的值是不可变的，但是它们可以被共享 字符串效果上相当于字符数组（char[]）,但是底层原理是字节数组（byte[]） */ String s1 =new String("abc"...
【零基础学Java】—字符串的概述和特点（十五）
道阻且长，行则将至。
04-08 449
【零基础学Java】—字符串的概述和特点（十五） 一、字符串的特点 java.lang.String类代表字符串 API当中说：Java程序中的所有字符串字面值（如：“abc”)都作为此类的实例对象 其实也就是说，程序当中的所有双引号字符串，都是String类的对象（就算没有new，也照样是） 字符串的特点： 字符串的内容用不可变 正式因为字符串不可改变，所以字符串是共享使用的 字符串效果上相当于char[]字符数组，但是底层原理是byte[]字节数组 二、创建字符串 创建字符串的3+1种方式 三种
字符串总结
sz1125218970的博客
10-18 1140
py笔记
字符串是什么？
weixin_44540481的博客
05-08 1万+
一、名词介绍 字符串或串(String)是由数字、字母、下划线组成的一串字符。它是编程语言中表示文本的数据类型。在程序设计中，字符串为符号或数值的一个连续序列。字符串操作就是以串的整体作为操作对象，如：在串中查找某个子串、求取一个子串、在串的某个位置上插入一个子串以及删除一个子串等。 二、串的定义 1.串是字符串的简称。在数据结构中，串是一种在数据元素的组成上具有一定约束条件的线性表...
字符串到底是什么？
fang 0 jun的博客
10-08 1774
文章目录字符串的本质字符串常量相关字符串数组和初始化 字符串的本质 // 探究一个字符串由什么构成 #include<stdio.h> int main(){ char arr[50] = "asdasdasdasdasdasd"; printf("以%c打印整个字符串数组"); for(int i = 0; i < 50; i++)printf("%c ", arr[i]); printf("\n"); printf("以%d打印整个字符串数组"); for(int i
数据结构与算法 - 字符串匹配
最新发布
05-12
字符串匹配是指在一个主串中查找一个模式串的出现位置。在计算机领域中，字符串匹配是一个重要的基础问题，应用广泛。常见的字符串匹配算法有暴力匹配、KMP算法、Boyer-Moore算法等。 暴力匹配算法是最简单的一种字符串匹配算法，也称为朴素匹配算法。其基本思想是：从主串的第一个字符开始，与模式串的第一个字符进行比较，若相等，则继续比较主串和模式串的下一个字符；若不相等，则从主串的第二个字符开始，再重新与模式串的第一个字符进行比较，以此类推，直到找到模式串在主串中的匹配位置或者主串被匹配完为止。 KMP算法是一种高效的字符串匹配算法。它利用模式串的自身匹配特性，在匹配过程中尽可能减少比较次数，从而提高匹配效率。具体思路是：在匹配过程中，当模式串与主串某个字符不匹配时，根据已匹配的前缀和后缀信息，将模式串向右移动一定的位数，从而跳过一些不必要的比较。 Boyer-Moore算法是一种基于坏字符和好后缀规则的字符串匹配算法。它通过预处理模式串，得到每个字符在模式串中最后出现的位置和好后缀的后缀子串在模式串中匹配的位置，从而在匹配过程中尽可能跳过多余的比较，提高匹配效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值