【数据结构】数组和字符串（十三）：链式字符串的基本操作（串长统计、查找、复制、插入、删除、串拼接）

文章目录

  • 4.3 字符串
    • 4.3.1 字符串的定义与存储
    • 4.3.2 字符串的基本操作（链式存储）
      • 1. 结构体
      • 2. 初始化
      • 3. 判空
      • 4. 串尾添加
      • 5. 打印
      • 6. 串长统计
      • 7. 查找
      • 8. 复制
      • 9. 插入
      • 10. 删除
      • 11. 串拼接
      • 12. 销毁
      • 13. 主函数
      • 14. 代码整合

4.3 字符串

  字符串(String)是由零个或多个字符(char)顺序排列组成的有限序列，简称为串。例如 “good morning”就是由12个字符构成的一个字符串。一般把字符串记作：

S = ′ ′ a 0 a 1 … a n − 1 ′ ′ S=''a_{0} a_{1}…a_{n-1}'' S=′′a0​a1​…an−1′′​

  其中S是串名，引号中的字符序列是串值。字符个数是串的长度，长度为0的串被称为空串，因为它不包含任何字符。需要注意的是，空格字符（" "）并不是空串，因为它包含一个字符——空格。
  若把某个串称为主串，则主串中任意个连续的字符组成的子序列被称为子串。子串在主串中第一次出现时，其首字符在主串中的序号被称为该子串在主串中的位置。
  关于字符串的基础知识亦可参考前文：
【重拾C语言】六、批量数据组织（三）数组初值；字符串、字符数组、字符串数组；类型定义 typedef
【重拾C语言】七、指针（三）指针与字符串（字符串与字符串数组；指针与字符串的遍历、拷贝、比较；反转字符串）

4.3.1 字符串的定义与存储

  字符串在许多非数值计算问题中扮演着重要的角色，并在模式匹配、程序编译和数据处理等领域得到广泛应用。在高级程序设计语言中，字符串通常被定义为以特殊字符’\0’（称为空字符或字符串结束符）结尾的字符序列。这个约定使得在处理字符串时可以方便地确定字符串的结束位置。关于字符串的存储方式，主要有两种常见的方式：

  • 顺序存储：字符串的字符按照顺序依次存储在连续的内存空间中。这种方式使得字符串的访问和操作效率较高，可以通过索引直接访问任意位置的字符。在顺序存储方式中，字符串的长度可以通过计算字符个数或者遇到’\0’结束符来确定。

  • 链式存储：字符串的字符通过链表的方式进行存储。每个节点包含一个字符和指向下一个节点的指针。链式存储方式可以动态地分配内存，适用于长度可变的字符串。但是相比于顺序存储，链式存储方式需要更多的内存空间，并且访问字符需要遍历链表。

  选择何种存储方式取决于具体的应用场景和需求。顺序存储适合于需要频繁访问和操作字符串的情况，而链式存储适合于长度可变的字符串或者对内存空间要求较高的情况。具体C语言实现可参照前文：
  【数据结构】数组和字符串（十一）：字符串的定义与存储（顺序存储、链式存储及其C语言实现）

4.3.2 字符串的基本操作（链式存储）

  • 串长统计返回串s的长度；
  • 串定位返回字符或子串在母串s中首次出现的位置的指针；
  • 串复制将一个串s2复制到另一个串s1中；
  • 串插入在指定位置后面插入字符串；
  • 串删除是删除一个子串；
  • 串拼接将串s2拼接到串s1的尾部；
  • ……

  【数据结构】线性表（二）单链表及其基本操作（创建、插入、删除、修改、遍历打印）

1. 结构体

typedef struct Node {char data;struct Node* next;
} Node;typedef struct {Node* head;Node* tail;
} LinkedList;
  • Node：表示链表的节点，包含一个字符数据和一个指向下一个节点的指针。
  • LinkedList：表示链表，包含链表的头节点和尾节点。

2. 初始化

  initLinkedList函数：用于初始化链表，将头节点和尾节点都设置为NULL。

void initLinkedList(LinkedList* list) {list->head = NULL;list->tail = NULL;
}

3. 判空

  isEmpty函数：判断链表是否为空，即头节点是否为NULL。

bool isEmpty(const LinkedList* list) {return list->head == NULL;
}

4. 串尾添加

   append函数：向链表末尾添加一个字符节点。

void append(LinkedList* list, char data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = NULL;if (isEmpty(list)) {list->head = newNode;list->tail = newNode;} else {list->tail->next = newNode;list->tail = newNode;}
}
  • 如果链表为空，即头节点为NULL，则将新节点设置为头节点和尾节点。
  • 如果链表不为空，即头节点不为NULL，则将新节点链接到尾节点的后面，并将尾节点更新为新节点。

5. 打印

   display函数：遍历链表并打印出所有字符节点的数据。

void display(const LinkedList* list) {Node* current = list->head;while (current != NULL) {printf("%c", current->data);current = current->next;}printf("\n");
}
  • 函数接受一个指向LinkedList结构体的指针作为参数，然后从头节点开始遍历链表，打印每个节点的数据。

6. 串长统计

   length函数：计算链表的长度，即字符节点的个数。

int length(const LinkedList* list) {int count = 0;Node* current = list->head;while (current != NULL) {count++;current = current->next;}return count;
}
  • 函数接受一个指向LinkedList结构体的指针作为参数，然后从头节点开始遍历链表，每遍历一个节点，计数器加1，最后返回计数器的值。

7. 查找

   search函数：在链表中搜索目标字符串。

int search(const LinkedList* list, const char* target) {int targetLength = strlen(target);int listLength = length(list);if (targetLength > listLength) {printf("Error: Target string is longer than the source string.\n");return -1;}Node* current = list->head;int index = 0;while (current != NULL) {if (current->data == target[0]) {Node* temp = current;int i = 0;while (temp != NULL && temp->data == target[i]) {temp = temp->next;i++;if (i == targetLength) {return index;}}}current = current->next;index++;}printf("Error: Target string not found in the source string.\n");return -1;
}
  • 首先比较目标字符串的长度和链表的长度，如果目标字符串比链表长，说明无法找到目标字符串，函数返回错误。
  • 然后从头节点开始遍历链表，找到第一个与目标字符串首字符相同的节点，
    • 然后从该节点开始逐个比较字符，直到找到完全匹配的目标字符串或链表遍历结束。
    • 如果找到目标字符串，函数返回目标字符串在链表中的起始位置的索引；
    • 如果未找到目标字符串，函数返回错误。

8. 复制

  copy函数：将源链表中的字符复制到目标链表中。

bool copy(LinkedList* dest, const LinkedList* src) {Node* current = src->head;while (current != NULL) {append(dest, current->data);current = current->next;}return true;
}
  • 函数接受两个指向LinkedList结构体的指针，分别表示源链表和目标链表。
  • 通过遍历源链表的每个节点，创建一个新节点并将数据复制过去，然后将新节点添加到目标链表的末尾。

9. 插入

   insert函数：在链表的指定位置插入一个字符串。

bool insert(LinkedList* list, const char* insertStr, int pos) {int listLength = length(list);int insertStrLength = strlen(insertStr);if (pos < 0 || pos > listLength) {printf("Error: Invalid insertion position.\n");return false;}Node* current = list->head;int index = 0;while (current != NULL) {if (index == pos) {for (int i = 0; i < insertStrLength; i++) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = insertStr[i];newNode->next = current->next;current->next = newNode;current = newNode;}return true;}current = current->next;index++;}return false;
}
  • 首先判断插入位置是否合法，即索引是否在有效范围内。然后遍历链表找到插入位置的节点，然后逐个创建新节点并插入到链表中。

10. 删除

  delete函数：从链表中删除指定位置和长度的字符。

bool delete(LinkedList* list, int pos, int len) {int listLength = length(list);if (pos < 0 || pos >= listLength) {printf("Error: Invalid deletion position.\n");return false;}if (pos + len > listLength) {printf("Error: Deletion length exceeds the length of the string.\n");return false;}Node* current = list->head;int index = 0;while (current != NULL) {if (index == pos) {Node* prev = current;Node* temp = current;for (int i = 0; i < len; i++) {temp = temp->next;free(prev);prev = temp;}current->next = temp;return true;}current = current->next;index++;}return false;
}
  • 首先判断删除位置是否合法，然后找到删除位置的节点，逐个删除指定长度的节点。

11. 串拼接

  concat函数：将第二个链表中的字符追加到第一个链表的末尾。的末尾。

bool concat(LinkedList* list1, const LinkedList* list2) {Node* current = list2->head;while (current != NULL) {append(list1, current->data);current = current->next;}return true;
}
  • 遍历第二个链表的每个节点，将节点的数据追加到第一个链表。

12. 销毁

  destroy函数：释放链表占用的内存。遍历链表的每个节点，释放节点的内存，并将头节点和尾节点设置为NULL。

void destroy(LinkedList* list) {Node* current = list->head;while (current != NULL) {Node* temp = current;current = current->next;free(temp);}list->head = NULL;list->tail = NULL;
}
  • 函数遍历链表的每个节点，释放节点的内存，并将头节点和尾节点设置为NULL。

13. 主函数


int main() {LinkedList S;initLinkedList(&S);const char target[] = "H";LinkedList copyStr;initLinkedList(&copyStr);const char insertStr[] = "H";int pos = 3;append(&S, 'q');append(&S, 'o');append(&S, 'm');append(&S, 'o');append(&S, 'l');append(&S, 'a');append(&S, 'n');append(&S, 'g');append(&S, 'm');append(&S, 'a');display(&S);int searchIndex = search(&S, target);if (searchIndex != -1) {printf("Target string found at index: %d\n", searchIndex);}copy(&copyStr, &S);display(&copyStr);insert(&S, insertStr, pos);display(&S);delete(&S, pos, strlen(insertStr));display(&S);concat(&S, &copyStr);display(&S);destroy(&S);destroy(&copyStr);return 0;
}

在这里插入图片描述

14. 代码整合

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>typedef struct Node {char data;struct Node* next;
} Node;typedef struct {Node* head;Node* tail;
} LinkedList;void initLinkedList(LinkedList* list) {list->head = NULL;list->tail = NULL;
}bool isEmpty(const LinkedList* list) {return list->head == NULL;
}void append(LinkedList* list, char data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = NULL;if (isEmpty(list)) {list->head = newNode;list->tail = newNode;} else {list->tail->next = newNode;list->tail = newNode;}
}void display(const LinkedList* list) {Node* current = list->head;while (current != NULL) {printf("%c", current->data);current = current->next;}printf("\n");
}int length(const LinkedList* list) {int count = 0;Node* current = list->head;while (current != NULL) {count++;current = current->next;}return count;
}int search(const LinkedList* list, const char* target) {int targetLength = strlen(target);int listLength = length(list);if (targetLength > listLength) {printf("Error: Target string is longer than the source string.\n");return -1;}Node* current = list->head;int index = 0;while (current != NULL) {if (current->data == target[0]) {Node* temp = current;int i = 0;while (temp != NULL && temp->data == target[i]) {temp = temp->next;i++;if (i == targetLength) {return index;}}}current = current->next;index++;}printf("Error: Target string not found in the source string.\n");return -1;
}bool copy(LinkedList* dest, const LinkedList* src) {Node* current = src->head;while (current != NULL) {append(dest, current->data);current = current->next;}return true;
}bool insert(LinkedList* list, const char* insertStr, int pos) {int listLength = length(list);int insertStrLength = strlen(insertStr);if (pos < 0 || pos > listLength) {printf("Error: Invalid insertion position.\n");return false;}Node* current = list->head;int index = 0;while (current != NULL) {if (index == pos) {for (int i = 0; i < insertStrLength; i++) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = insertStr[i];newNode->next = current->next;current->next = newNode;current = newNode;}return true;}current = current->next;index++;}return false;
}bool delete(LinkedList* list, int pos, int len) {int listLength = length(list);if (pos < 0 || pos >= listLength) {printf("Error: Invalid deletion position.\n");return false;}if (pos + len > listLength) {printf("Error: Deletion length exceeds the length of the string.\n");return false;}Node* current = list->head;int index = 0;while (current != NULL) {if (index == pos) {Node* prev = current;Node* temp = current;for (int i = 0; i < len; i++) {temp = temp->next;free(prev);prev = temp;}current->next = temp;return true;}current = current->next;index++;}return false;
}bool concat(LinkedList* list1, const LinkedList* list2) {Node* current = list2->head;while (current != NULL) {append(list1, current->data);current = current->next;}return true;
}void destroy(LinkedList* list) {Node* current = list->head;while (current != NULL) {Node* temp = current;current = current->next;free(temp);}list->head = NULL;list->tail = NULL;
}int main() {LinkedList S;initLinkedList(&S);const char target[] = "H";LinkedList copyStr;initLinkedList(&copyStr);const char insertStr[] = "H";int pos = 3;append(&S, 'q');append(&S, 'o');append(&S, 'm');append(&S, 'o');append(&S, 'l');append(&S, 'a');append(&S, 'n');append(&S, 'g');append(&S, 'm');append(&S, 'a');display(&S);int searchIndex = search(&S, target);if (searchIndex != -1) {printf("Target string found at index: %d\n", searchIndex);}copy(&copyStr, &S);display(&copyStr);insert(&S, insertStr, pos);display(&S);delete(&S, pos, strlen(insertStr));display(&S);concat(&S, &copyStr);display(&S);destroy(&S);destroy(&copyStr);return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/158578.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

模电学习路径

模电学习路径

交流通路实质 列出电路方程1&#xff0c;方程1对时刻t做微分 所得方程1‘ 即为 交流通路 方程1对时刻t做微分&#xff1a;两个不同时刻的方程1相减&#xff0c;并 令两时刻差为 无穷小 微分 改成 差 模电学习路径&#xff1a; 理论 《电路原理》清华大学 于歆杰 朱桂萍 陆文…
阅读更多...
ES-初识ES

ES-初识ES

文章目录 介绍ElasticSearchElasticSearch的主要功能ElasticSearch的主要特性ElasticSearch的家族成员LogStashKibanaBeats ELK&#xff08;ElasticSearch LogStash Kibana&#xff09;的应用场景与数据库集成指标采集/日志分析 安装和配置ElasticSearch一、安装1、下载ES安装…
阅读更多...
【Linux】Nignx的入门使用负载均衡动静分离(前后端项目部署)---超详细

【Linux】Nignx的入门使用负载均衡动静分离(前后端项目部署)---超详细

一&#xff0c;Nignx入门 1.1 Nignx是什么 Nginx是一个高性能的开源Web服务器和反向代理服务器。它使用事件驱动的异步框架&#xff0c;可同时处理大量请求&#xff0c;支持负载均衡、反向代理、HTTP缓存等常见Web服务场景。Nginx可以作为一个前端的Web服务器&#xff0c;也可…
阅读更多...
Python能够超过JAVA吗？

Python能够超过JAVA吗？

前言 如果你定期关注现今的科技发展&#xff0c;那么你可能想知道我为什么要写这篇文章告诉人们学习Python&#xff1f;因为几年前我提倡Java而不是Python。 Python是最适用于人工智能的编程语言&#xff0c;伴随着人工智能时代的到来&#xff0c;Python变得越来越火&#xf…
阅读更多...
系列四、全局配置文件mybatis-config.xml

系列四、全局配置文件mybatis-config.xml

一、全局配置文件中的属性 mybatis全局配置中的文件非常多&#xff0c;主要有如下几个&#xff1a; properties&#xff08;属性&#xff09;settings&#xff08;全局配置参数&#xff09;typeAliases&#xff08;类型别名&#xff09;typeHandlers&#xff08;类型处理器&am…
阅读更多...
http1,https,http2,http3总结

http1,https,http2,http3总结

1.HTTP 当我们浏览网页时&#xff0c;地址栏中使用最多的多是https://开头的url&#xff0c;它与我们所学的http协议有什么区别&#xff1f; http协议又叫超文本传输协议&#xff0c;它是应用层中使用最多的协议&#xff0c; http与我们常说的socket有什么区别吗&#xff1f; …
阅读更多...
【mfc/VS2022】计图实验:绘图工具设计知识笔记3

【mfc/VS2022】计图实验:绘图工具设计知识笔记3

实现类对串行化的支持 如果要用CArchive类保存对象的话&#xff0c;那么这个对象的类必须支持串行化。一个可串行化的类通常有一个Serialize成员函数。要想使一个类可串行化&#xff0c;要经历以下5个步骤&#xff1a; 1、从CObject派生类 2、重写Serialize成员函数 3、使用DE…
阅读更多...
上海物理、化学高考命题趋势及2024年上海物理、化学高考备考建议

上海物理、化学高考命题趋势及2024年上海物理、化学高考备考建议

在上海高考时&#xff0c;物理、化学虽然不像语文、英语和数学那样分数高&#xff0c;但是仍然很重要。那么&#xff0c;从这几年的上海物理、化学的高考题目来看&#xff0c;我们互发现什么命题趋势和考题特点呢&#xff1f;如何备考接下来的2024年高考物理和化学呢&#xff1…
阅读更多...
jar包的精细化运营，Java模块化简介 | 京东云技术团队

jar包的精细化运营，Java模块化简介 | 京东云技术团队

图&#xff1a;模块化手机概念 一、什么是Java模块化 Java模块化&#xff08;module&#xff09;是Java9及以后版本引入的新特性。 官方对模块的定义为&#xff1a;一个被命名的&#xff0c;代码和数据的自描述集合。&#xff08; the module, which is a named, self-descri…
阅读更多...
外汇天眼：账户惨遭冻结？一招帮你解决问题！

外汇天眼：账户惨遭冻结？一招帮你解决问题！

在外汇交易中&#xff0c;难免会出现大大小小的问题&#xff0c;其中账户被冻结也是经常能够见到的。首先摒弃外汇黑平台&#xff0c;在正规的外汇平台&#xff0c;如果出现账户被冻结的问题&#xff0c;可能是以下几种原因&#xff1a; 第一种是使用平台禁止的辅助软件进行薅…
阅读更多...
JVS低代码表单引擎助你打造高效表单设计流程

JVS低代码表单引擎助你打造高效表单设计流程

在日常的设计表单过程中&#xff0c;常常会有需要录入一大段文字的场景&#xff0c;例如评论、留言、产品介绍、内容说明等场景&#xff0c;那么简单的文本框组件就不满足了&#xff0c;这里JVS提供了 两种描述类型的组件&#xff0c;多行文本框和富文本组件&#xff0c;如下图…
阅读更多...
数据结构 - 顺序表ArrayList

数据结构 - 顺序表ArrayList

目录 实现一个通用的顺序表 总结 包装类 装箱 / 装包 和 拆箱 / 拆包 ArrayList 与 顺序表 ArrayList基础功能演示 add 和 addAll &#xff0c;添加元素功能 ArrayList的扩容机制 来看一下&#xff0c;下面的代码是否存在缺陷 模拟实现 ArrayList add 功能 add ind…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023