• 【数据结构】串的定义；存储结构；基本操作的实现

     欢迎光~临~^_^

    目录

    知识树 

    1、串的定义

    2、串的存储结构

    2.1顺序存储

    静态存储

    动态存储

    2.2链式存储 

    2.3串的堆分配存储表示

    3、串的基本操作

    3.1求子串

    3.2比较操作

    3.3定位操作 

    4、C语言实现串的基本操作 

    知识树 

     

     

    1、串的定义

            串是由零个或多个字符组成的有限序列。在计算机科学中，常用串来表示文本、代码或数据。串是程序设计中重要的基本数据类型之一，常用于字符串匹配、文本处理和密码学等领域。

            子串是指在一个字符串中取出一段连续的字符所得到的字符串。例如，在字符串 "hello world" 中，"hello"、"world"、"lo"、"l"、"rld" 都是它的子串。

            空串指的是没有任何字符的字符串，表示为 ""（两个引号之间没有任何字符）。而空格串指的是只包含空格字符的字符串，例如 " "。虽然两者在形式上都是字符串，但含义不同。

    2、串的存储结构

    2.1顺序存储

    静态存储

            串的静态存储指的是在程序运行时在固定的内存地址上分配空间来存储串。在静态存储中，串的长度是固定的，不能动态地改变。通常，在编写程序时，我们可以使用字符数组来存储字符串，这样可以方便地对字符串进行操作和访问。

    例如，在C语言中，可以通过以下方式来定义一个静态的字符串：

    1. char str[] = "hello world";
    2.

            这里，str是一个字符数组，被初始化为字符串"hello world"。在编译时，系统会为str分配一个固定的内存空间，用来存储这个字符串。在程序运行时，我们可以通过str来访问和修改这个字符串。需要注意的是，这个字符串的长度是固定的，即为11（包括字符串末尾的'\0'字符）。如果我们需要动态地改变字符串的长度，就需要使用动态存储方式，如堆内存或栈内存。

    动态存储

            串的动态存储一般采用字符数组或链表进行实现。

    1.字符数组

    字符数组是串的静态存储方式，但可以通过动态分配内存来实现动态存储。具体实现方法为：

    （1）定义一个字符指针变量，用于指向动态分配的字符数组。

    （2）根据实际需要确定串的最大长度，调用C语言中的动态内存分配函数malloc()申请空间。

    （3）将申请到的空间赋值给字符指针变量。

    （4）通过scanf()、gets()等函数向分配的空间中读入字符。

    （5）使用完后，需要释放已分配的内存空间，以便于其他程序使用。

    示例代码：

    1. #include 
    2. #include 
    3.  
    4. int main()
    5. {
    6.     char* str;
    7.     int len;
    8.     printf("Input the length of the string:");
    9.     scanf("%d", &len);
    10.     str = (char*)malloc(len * sizeof(char));
    11.     if (!str)
    12.     {
    13.         printf("Memory allocation failed!\n");
    14.         return 0;
    15.     }
    16.     printf("Input the string:");
    17.     scanf("%s", str);
    18.     printf("The string you input is:%s\n", str);
    19.     free(str);
    20.     return 0;
    21. }
    22.

    2.链表 

    链表是动态存储的一种常见方式，可以在运行时动态增加或删除节点。对于串的存储，链表的每个节点都可以存储一个字符。链表的实现方法如下：

    （1）定义一个节点结构体，包含一个字符变量和一个指向下一个节点的指针变量。

    （2）定义一个头指针变量，用于指向链表的第一个节点。

    （3）通过调用C语言的动态内存分配函数malloc()申请一个节点，并将节点的指针挂在链表的末尾。

    （4）向新申请的节点中存入要存储的字符。

    （5）通过指针操作，可以在链表中进行插入、删除、修改等操作。

    （6）使用完链表后，需要释放每个节点占用的内存空间。

    示例代码：

    1. #include 
    2. #include 
    3.  
    4. typedef struct node {
    5.     char data;
    6.     struct node* next;
    7. }Node;
    8.  
    9. int main()
    10. {
    11.     Node* head = NULL;
    12.     Node* tail = NULL;
    13.     char c;
    14.     printf("Input the string:");
    15.     while ((c = getchar()) != '\n')
    16.     {
    17.         Node* p = (Node*)malloc(sizeof(Node));
    18.         p->data = c;
    19.         p->next = NULL;
    20.         if (head == NULL)
    21.         {
    22.             head = p;
    23.             tail = p;
    24.         }
    25.         else
    26.         {
    27.             tail->next = p;
    28.             tail = tail->next;
    29.         }
    30.     }
    31.     printf("The string you input is:");
    32.     Node* p = head;
    33.     while (p)
    34.     {
    35.         printf("%c", p->data);
    36.         p = p->next;
    37.     }
    38.     p = head;
    39.     while (p)
    40.     {
    41.         Node* t = p;
    42.         p = p->next;
    43.         free(t);
    44.     }
    45.     return 0;
    46. }
    47.

    2.2链式存储 

            链式存储方式是通过链表来存储串的每个字符。每个结点存储一个或多个字符，同时包括一个指向下一个结点的指针。链式存储的结构体如下所示：

    1. typedef struct StringNode {
    2.     char data[MAXSIZE]; // 存储字符数组
    3.     int length; // 存储当前结点存储的字符个数
    4.     struct StringNode *next; // 指向下一个结点的指针
    5. } StringNode, *String;
    6.

            其中 MAXSIZE 是存储字符数组的最大长度，length 表示当前结点存储的字符个数。一个完整的链表存储了整个串，其中头结点不存储数据，只作为链表的链头，串的实际数据从第二个结点开始存储。

            需要注意的是，链式存储的串的空间是动态分配的，因此可以根据具体的需求动态调整存储空间。但是，链式存储的串在访问任意一个字符时需要遍历整个链表，因此在时间复杂度上可能会存在一定的问题。

    2.3串的堆分配存储表示

    可以使用动态内存分配来实现堆分配存储表示。具体实现方法如下：

    1. 使用malloc函数分配一块连续的内存空间，该空间位于堆区；
    2. 将需要存储的串拷贝到该内存空间中；
    3. 返回指向该内存空间的指针，作为串的堆分配存储表示。

    例如，以下代码演示了如何使用动态内存分配来实现堆分配存储表示的字符串拷贝操作：

    1. #include   
    2. #include   
    3. #include  
    4.  
    5. char* copy_string(char* str) {  
    6.     int len = strlen(str);  
    7.     char* new_str = (char*)malloc(len + 1); // 分配内存空间  
    8.     strcpy(new_str, str); // 拷贝字符串到新的内存空间中  
    9.     return new_str; // 返回指针  
    10. }  
    11.  
    12. int main() {  
    13.     char* str = "Hello, world!";  
    14.     char* new_str = copy_string(str); // 使用动态内存分配实现堆分配存储表示  
    15.     printf("%s\n", new_str);  
    16.     free(new_str); // 释放内存空间  
    17.     return 0;  
    18. }  
    19.

            在该代码中，copy_string函数使用malloc函数分配了一块内存空间，将传入的字符串拷贝到该空间中，并返回指向该空间的指针。在main函数中，调用copy_string函数将字符串"Hello, world!"拷贝到堆中，并输出该字符串。最后，使用free函数释放动态分配的内存空间，避免内存泄漏。

     

    3、串的基本操作

    3.1求子串

    下面是C语言实现求串的子串的代码，其中包括了两种常见的方法：

    方法一：暴力枚举

    1. #include 
    2. #include 
    3.  
    4. int substr(char* str, char* sub) {
    5.     int i, j, k;
    6.     int len1 = strlen(str);
    7.     int len2 = strlen(sub);
    8.     for (i = 0; i <= len1 - len2; i++) {
    9.         k = i;
    10.         for (j = 0; j < len2; j++) {
    11.             if (str[k] == sub[j]) {
    12.                 k++;
    13.             } else {
    14.                 break;
    15.             }
    16.         }
    17.         if (j == len2) {
    18.             return i;
    19.         }
    20.     }
    21.     return -1;
    22. }
    23.  
    24. int main() {
    25.     char str[] = "hello world";
    26.     char sub[] = "world";
    27.     int index = substr(str, sub);
    28.     if (index < 0) {
    29.         printf("不存在子串");
    30.     } else {
    31.         printf("子串在主串中的位置是：%d", index);
    32.     }
    33.     return 0;
    34. }
    35.

    方法二：KMP算法（重重重难难难点）

    1. #include 
    2. #include 
    3.  
    4. void getNext(char* t, int* next) {
    5.     int i = 0, j = -1;
    6.     int len = strlen(t);
    7.     next[0] = -1;
    8.     while (i < len - 1) {
    9.         if (j == -1 || t[i] == t[j]) {
    10.             i++;
    11.             j++;
    12.             next[i] = j;
    13.         } else {
    14.             j = next[j];
    15.         }
    16.     }
    17. }
    18.  
    19. int kmp(char* s, char* t, int* next) {
    20.     int i = 0, j = 0;
    21.     int len1 = strlen(s);
    22.     int len2 = strlen(t);
    23.     while (i < len1 && j < len2) {
    24.         if (j == -1 || s[i] == t[j]) {
    25.             i++;
    26.             j++;
    27.         } else {
    28.             j = next[j];
    29.         }
    30.     }
    31.     if (j == len2) {
    32.         return i - j;
    33.     } else {
    34.         return -1;
    35.     }
    36. }
    37.  
    38. int main() {
    39.     char str[] = "hello world";
    40.     char sub[] = "world";
    41.     int next[strlen(sub)];
    42.     getNext(sub, next);
    43.     int index = kmp(str, sub, next);
    44.     if (index < 0) {
    45.         printf("不存在子串");
    46.     } else {
    47.         printf("子串在主串中的位置是：%d", index);
    48.     }
    49.     return 0;
    50. }
    51.

            两种方法的时间复杂度都是O(nm)，其中n为主串的长度，m为子串的长度。但是在不同的情况下，它们的效率会有所不同，暴力枚举适用于简单的匹配问题，而KMP算法适用于较复杂的匹配问题。

    3.2比较操作

    1. #include 
    2. #include 
    3.  
    4. int main()
    5. {
    6.     char str1[50], str2[50];
    7.     int result;
    8.  
    9.     printf("Enter string 1: ");
    10.     scanf("%s", str1);
    11.  
    12.     printf("Enter string 2: ");
    13.     scanf("%s", str2);
    14.  
    15.     result = strcmp(str1, str2);
    16.  
    17.     if(result < 0)
    18.     {
    19.         printf("String 1 is less than string 2\n");
    20.     }
    21.     else if(result > 0)
    22.     {
    23.         printf("String 1 is greater than string 2\n");
    24.     }
    25.     else
    26.     {
    27.         printf("Both strings are equal\n");
    28.     }
    29.  
    30.     return 0;
    31. }
    32.

            在上面的程序中，我们首先定义了两个字符串变量 str1 和 str2，然后使用 scanf 函数分别从用户输入中读取这两个字符串。接下来，我们使用 strcmp 函数对两个字符串进行比较，并将比较结果赋值给 result 变量。最后，我们使用 if-else 语句来判断 result 的值，根据比较结果输出相应的信息。

      strcmp 函数用于比较两个字符串的大小，当第一个字符串小于第二个字符串时返回一个负值，当第一个字符串大于第二个字符串时返回一个正值，当两个字符串相等时返回 0。因此，在上面的程序中，我们使用 if-else 语句对三种情况进行了判断。

    3.3定位操作 

    在字符串操作中，最基本的操作是定位一个子串，即在一个给定的串中找到一个子串的位置。

    常见的定位子串的操作包括：

    1. 暴力匹配算法：从主串的第一个字符开始与子串逐个字符比较。如果出现不匹配的字符，则从下一个字符开始重新比较。时间复杂度为$O(mn)$，其中m是子串的长度，n是主串的长度。

    2. KMP算法：KMP算法是一种改进的暴力匹配算法，在匹配过程中根据已匹配的字符数目和子串本身的结构，跳过一些无需匹配的字符，从而提高匹配效率。时间复杂度为$O(m+n)$，其中m是子串的长度，n是主串的长度。

    3. Boyer-Moore算法：BM算法是一种基于字符比较跳跃的算法，可以在最坏情况下只需要比较n/m次，从而提高匹配效率。时间复杂度为$O(m+n)$，其中m是子串的长度，n是主串的长度。

    4. Rabin-Karp算法：RK算法利用哈希值来比较子串和主串，从而提高匹配效率。时间复杂度为$O(mn)$，但在实际应用中，通常能够达到较高的效率。

    以上算法中，KMP算法和Boyer-Moore算法是比较常用的定位子串的算法。

    4、C语言实现串的基本操作 

            在下面的程序中，我们用 get_length 函数求字符串长度，用 assign_string 函数进行字符串赋值，用 compare_string 函数比较两个字符串大小，用 concat_string 函数进行串连接，用 sub_string 函数求子串，用 replace_string 函数替换字符串中的某一部分，以及用 find_string 函数进行定位操作。

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. #define MAX_LEN 100
    6.  
    7. // 求字符串长度
    8. int get_length(char* str){
    9.     int count = 0;
    10.     while(str[count] != '\0'){
    11.         count++;
    12.     }
    13.     return count;
    14. }
    15.  
    16. // 字符串赋值
    17. void assign_string(char* str1, char* str2){
    18.     int len = get_length(str2);
    19.     for(int i = 0; i < len; i++){
    20.         str1[i] = str2[i];
    21.     }
    22.     str1[len] = '\0';
    23. }
    24.  
    25. // 比较两个字符串大小
    26. int compare_string(char* str1, char* str2){
    27.     int len1 = get_length(str1);
    28.     int len2 = get_length(str2);
    29.     int len = len1 < len2 ? len1 : len2;
    30.     for(int i = 0; i < len; i++){
    31.         if(str1[i] != str2[i]){
    32.             return str1[i] - str2[i];
    33.         }
    34.     }
    35.     return len1 - len2;
    36. }
    37.  
    38. // 串连接
    39. void concat_string(char* str1, char* str2){
    40.     int len1 = get_length(str1);
    41.     int len2 = get_length(str2);
    42.     for(int i = 0; i < len2; i++){
    43.         str1[len1+i] = str2[i];
    44.     }
    45.     str1[len1+len2] = '\0';
    46. }
    47.  
    48. // 求子串
    49. void sub_string(char* str1, char* substr, int start, int len){
    50.     int len1 = get_length(str1);
    51.     if(start < 0 || start > len1 || len <= 0){
    52.         substr[0] = '\0'; // 空串
    53.         return;
    54.     }
    55.     if(start + len > len1){
    56.         len = len1 - start;
    57.     }
    58.     for(int i = 0; i < len; i++){
    59.         substr[i] = str1[start+i];
    60.     }
    61.     substr[len] = '\0';
    62. }
    63.  
    64. // 替换
    65. void replace_string(char* str1, char* old_str, char* new_str){
    66.     int len1 = get_length(str1);
    67.     int len_old = get_length(old_str);
    68.     int len_new = get_length(new_str);
    69.     int i, j, k;
    70.     for(i = 0; i < len1; i++){
    71.         if(str1[i] == old_str[0]){
    72.             for(j = 1; j < len_old; j++){
    73.                 if(str1[i+j] != old_str[j]){
    74.                     break;
    75.                 }
    76.             }
    77.             if(j == len_old){
    78.                 break;
    79.             }
    80.         }
    81.     }
    82.     if(i < len1){
    83.         if(len_old == len_new){
    84.             for(k = 0; k < len_new; k++){
    85.                 str1[i+k] = new_str[k];
    86.             }
    87.         }
    88.         else if(len_old < len_new){
    89.             int delta = len_new - len_old;
    90.             for(k = len1-1; k >= i+len_old; k--){
    91.                 str1[k+delta] = str1[k];
    92.             }
    93.             for(k = 0; k < len_new; k++){
    94.                 str1[i+k] = new_str[k];
    95.             }
    96.             str1[len1+delta] = '\0';
    97.         }
    98.         else{
    99.             int delta = len_old - len_new;
    100.             for(k = i+len_old; k <= len1; k++){
    101.                 str1[k-delta] = str1[k];
    102.             }
    103.             for(k = 0; k < len_new; k++){
    104.                 str1[i+k] = new_str[k];
    105.             }
    106.         }
    107.     }
    108. }
    109.  
    110. // 定位算法
    111. int find_string(char* str1, char* str2){
    112.     int len1 = get_length(str1);
    113.     int len2 = get_length(str2);
    114.     int i, j;
    115.     for(i = 0; i <= len1-len2; i++){
    116.         for(j = 0; j < len2; j++){
    117.             if(str1[i+j] != str2[j]){
    118.                 break;
    119.             }
    120.         }
    121.         if(j == len2){
    122.             return i; // 返回第一次出现的位置
    123.         }
    124.     }
    125.     return -1; // 没有找到
    126. }
    127.  
    128. int main(){
    129.     char str1[MAX_LEN], str2[MAX_LEN], substr[MAX_LEN], old_str[MAX_LEN], new_str[MAX_LEN];
    130.     int start, len, pos;
    131.     printf("Enter string 1: ");
    132.     scanf("%s", str1);
    133.     printf("Enter string 2: ");
    134.     scanf("%s", str2);
    135.     printf("String 1 length is %d\n", get_length(str1));
    136.     assign_string(str1, str2);
    137.     printf("String 1 after assign string 2: %s\n", str1);
    138.     printf("Compare string 1 and string 2: %d\n", compare_string(str1, str2));
    139.     concat_string(str1, str2);
    140.     printf("String 1 after concat string 2: %s\n", str1);
    141.     printf("Enter start index and length for substring: ");
    142.     scanf("%d%d", &start, &len);
    143.     sub_string(str1, substr, start, len);
    144.     printf("Substring: %s\n", substr);
    145.     printf("Enter string to be replaced: ");
    146.     scanf("%s", old_str);
    147.     printf("Enter replacement string: ");
    148.     scanf("%s", new_str);
    149.     replace_string(str1, old_str, new_str);
    150.     printf("String 1 after replace operation: %s\n", str1);
    151.     printf("Enter string to be searched: ");
    152.     scanf("%s", str2);
    153.     pos = find_string(str1, str2);
    154.     if(pos == -1){
    155.         printf("Entered string not found in string 1.\n");
    156.     }
    157.     else{
    158.         printf("Entered string found at position %d in string 1.\n", pos);
    159.     }
    160.     return 0;
    161. }
    162.

     🤞❤️🤞❤️🤞❤️串基本的知识点总结就到这里啦，如果对博文还满意的话，劳烦各位看官动动“发财的小手”留下您对博文的赞和对博主的关注吧🤞❤️🤞❤️🤞❤️

  • 相关阅读:
    uniapp中使用编辑器editor
    Linux 提权-Capabilities
    A股风格因子看板 (2023.11 第11期)
    Allegro Design Entry HDL（OrCAD Capture HDL）模块管理菜单详细介绍
    机器学习——回归
    51单片机——DS1302时钟
    11 场面试无一被拒 Alibaba 金九银十面试参考指南（Java 版）真香
    Kafka：C++ 实践
    深入理解 python 虚拟机：令人拍案叫绝的字节码设计
    Archery工单系统之inception 审计参数详解
  • 原文地址：https://blog.csdn.net/qq_52442214/article/details/132873250