第八周项目二(3) 顺序串算法测试-串内元素的删除

本文介绍了一种简单的字符串处理算法,用于从字符串中删除指定字符的所有实例。通过使用后一个元素覆盖要删除的元素来实现,最后更新字符串长度。

问题及代码

/*
*Copyright(c)2017,烟台大学计算机学院
*All right reserved.
*文件名:main.cpp sqstring.h string.cpp
*作者:王万兴
*完成日期:2017年10月19日
*版本号:v1.0
*
*问题描述:串内元素的删除
*输入描述:无
*程序输出:见运行结果
*/
#include <stdio.h>
#include "sqString.h"
void DellChar(SqString &s, char c)
{
    int k=0, i=0;   //k记录值等于c的字符个数
    while(i<s.length)
    {
        if(s.data[i]==c)
            k++;
        else
            s.data[i-k]=s.data[i];
        i++;
    }
    s.length -= k;
}

int main()
{
    SqString s;
    printf("删除前:");
    StrAssign(s, "message");
     DispStr(s);
    DellChar(s, 'e');
    printf("删除后:");
    DispStr(s);
    return 0;
}
运行结果


知识点总结

将要删除的元素用后一元素覆盖掉,实现元素的删除。



<think>首先,用户的问题是关于“实现顺序串各种基本运算的算法”。用户引用了站内引用[1],其中描述了一个实验内容,包括建立、输出、插入、删除、替换、提取和连接等操作。用户说“上述引用仅供参考”,所以我应该基于用户的核心问题来回答。 用户上一次的问题可能是关于顺序串的,但在这个查询中,用户直接问了“我想查找实现顺序串各种基本运算的算法”,所以我需要专注于这个。 系统指令要求: - 所有行内数学表达式使用$...$格式(但这里可能不涉及数学表达式,因为主题是字符操作)。 - 独立公式使用$$...$$格式并单独成段。 - LaTeX语法正确。 - 使用中文回答。 - 生成相关问题。 - 在回答中引用的段落末尾自然地添加引用标识,如[^1]。 用户引用了[^1],所以我需要在回答中自然地引用它。 结构回答: - 回答应该结构清晰,帮助用户逐步解决问题。 - 保证回答真实可靠。 主题是顺序串(sequential string),在数据结构中,通常是基于数组实现的字符。基本运算包括创建、输出、长度计算、插入、删除、替换、子提取和连接。 参考用户提供的引用: - 建立s="abcdefghijklmn"和s1="123" - 输出 - 输出长度 - 在指定位置插入 - 删除指定位置的字符 - 替换指定位置的子 - 提取子 - 连接两个 我需要解释这些操作的实现算法。 由于是算法描述,我应该用伪代码或中文描述算法步骤,而不涉及具体编程语言,除非必要。系统指令有示例使用Python代码,但用户的问题是算法,所以我应该优先用描述性语言。 在示例中,有Python代码块,所以我可以在适当的地方添加代码块来展示实现。 系统指令说:"生成相关问题",所以在回答末尾添加相关问题。 回答结构: 1. **引言**:简要介绍顺序串及其基本运算。 2. **算法描述**:为每个基本运算提供算法步骤或伪代码。 - 创建 - 输出 - 计算长度 - 插入 - 删除 - 替换子 - 提取子 - 连接 3. **整体实现**:提供一个简单的实现框架。 4. **相关问题**:在末尾生成相关问题。 使用中文回答。 自然地添加引用:用户提到引用[^1],所以在描述时,可以说基于引用[^1]的内容。 伪代码或代码块:类似于示例,使用代码块展示算法。示例中是Python,所以我可以用类似的语言。 在代码块中,用注释解释。 最终回答格式: - 以清晰段落组织。 - 代码块使用```language```格式。 - 末尾添加相关问题。 相关问题示例: - 顺序串与链式的区别? - 如何优化顺序串的插入操作? - 顺序串的应用场景? 确保内容真实可靠:基于标准数据结构知识。 </think>### 顺序串基本运算的实现算法 顺序串是一种基于数组存储的字符数据结构,通过连续内存单元存储字符序列。基本运算包括创建、输出、计算长度、插入、删除、替换、提取子和连接等操作。这些操作在字符处理中广泛应用,如文本编辑器和数据解析[^1]。下面我将基于标准数据结构原理,逐步解释每个基本运算的实现算法算法描述以伪代码为主,确保逻辑清晰;完整实现可参考C或Python语言,这里提供一个简化的Python示例框架。 #### 1. **建立(创建)** - **算法描述**:初始化一个字符数组,并赋值给定字符。时间复杂度为 $O(n)$,其中 $n$ 是字符长度。 - **伪代码**: ``` 函数 create_string(chars): 分配内存空间 str_array[0..n-1] // n 为 chars 的长度 for i 从 0 到 n-1: str_array[i] = chars[i] // 复制字符 返回 str_array 和相关长度属性 ``` #### 2. **输出** - **算法描述**:遍历字符数组,逐个输出字符。时间复杂度为 $O(n)$。 - **伪代码**: ``` 函数 print_string(str): for i 从 0 到 str.length-1: 输出 str[i] // 打印字符 ``` #### 3. **输出的长度** - **算法描述**:直接返回存储的长度属性,时间复杂度为 $O(1)$。 - **伪代码**: ``` 函数 get_length(str): 返回 str.length // 长度在创建时已存储 ``` #### 4. **在指定位置插入** - **算法描述**:将一个插入到另一个的指定索引处。需要检查索引有效性,并移动后续字符以腾出空间。时间复杂度为 $O(n+m)$,其中 $n$ 是原长度,$m$ 是插入长度。 - **伪代码**: ``` 函数 insert_string(src_str, insert_str, pos): 如果 pos < 0 或 pos > src_str.length: 返回错误 // 位置无效 新长度 new_len = src_str.length + insert_str.length 分配新数组 new_str[0..new_len-1] // 复制插入点前的字符 for i 从 0 到 pos-1: new_str[i] = src_str[i] // 复制插入 for j 从 0 到 insert_str.length-1: new_str[pos + j] = insert_str[j] // 复制插入点后的字符 for k 从 pos 到 src_str.length-1: new_str[k + insert_str.length] = src_str[k] 返回 new_str ``` #### 5. **删除指定位置的子** - **算法描述**:移除从指定索引开始的连续字符。需要移动后续字符填充空缺。时间复杂度为 $O(n)$。 - **伪代码**: ``` 函数 delete_substring(src_str, pos, num): 如果 pos < 0 或 pos >= src_str.length 或 num <= 0: 返回错误 // 参数无效 新长度 new_len = src_str.length - num 分配新数组 new_str[0..new_len-1] // 复制删除点前的字符 for i 从 0 到 pos-1: new_str[i] = src_str[i] // 跳过删除部分,复制剩余字符 for j 从 pos + num 到 src_str.length-1: new_str[j - num] = src_str[j] 返回 new_str ``` #### 6. **替换指定位置的子** - **算法描述**:将原中指定位置的子替换为新。本质是先删除旧子长度,再插入新。时间复杂度为 $O(n+m)$,其中 $m$ 是新长度。 - **伪代码**: ``` 函数 replace_substring(src_str, rep_str, pos, num): temp_str = delete_substring(src_str, pos, num) // 删除原子 new_str = insert_string(temp_str, rep_str, pos) // 插入新 返回 new_str ``` #### 7. **提取子(指定位置开始的子)** - **算法描述**:创建新,复制原从指定索引开始的连续字符。时间复杂度为 $O(n)$。 - **伪代码**: ``` 函数 substring(src_str, pos, num): 如果 pos < 0 或 pos >= src_str.length 或 num <= 0: 返回错误 新长度 new_len = min(num, src_str.length - pos) // 避免越界 分配新数组 new_str[0..new_len-1] for i 从 0 到 new_len-1: new_str[i] = src_str[pos + i] 返回 new_str ``` #### 8. **连接两个** - **算法描述**:将两个首尾相接形成新。时间复杂度为 $O(n+m)$。 - **伪代码**: ``` 函数 concat_string(str1, str2): 新长度 new_len = str1.length + str2.length 分配新数组 new_str[0..new_len-1] // 复制第一个 for i 从 0 到 str1.length-1: new_str[i] = str1[i] // 复制第 for j 到 0 到 str2.length-1: new_str[str1.length + j] = str2[j] 返回 new_str ``` #### 完整Python实现示例 基于上述算法,以下是一个简单的Python代码实现顺序串基本运算。Python中字符不可变,但这里模拟数组操作以符合顺序串原理。 ```python class SeqString: def __init__(self, chars=""): """建立: 初始化字符数组和长度""" self.data = list(chars) # 字符数组 self.length = len(chars) # 长度属性 def print_string(self): """输出: 遍历并打印字符""" print(&#39;&#39;.join(self.data)) def get_length(self): """输出的长度: 返回存储的长度""" return self.length def insert_string(self, insert_str, pos): """在指定位置插入: 移动字符腾出空间""" if pos < 0 or pos > self.length: raise IndexError("位置无效") # 创建新数组并插入 new_data = self.data[:pos] + list(insert_str) + self.data[pos:] return SeqString(&#39;&#39;.join(new_data)) def delete_substring(self, pos, num): """删除指定位置的子: 移动字符填充空缺""" if pos < 0 or pos >= self.length or num <= 0: raise IndexError("参数无效") end = min(pos + num, self.length) # 避免越界 new_data = self.data[:pos] + self.data[end:] return SeqString(&#39;&#39;.join(new_data)) def replace_substring(self, rep_str, pos, num): """替换子: 删除后插入新""" temp = self.delete_substring(pos, num) return temp.insert_string(rep_str, pos) def substring(self, pos, num): """提取子: 复制指定范围的字符""" if pos < 0 or pos >= self.length or num <= 0: raise IndexError("参数无效") end = min(pos + num, self.length) return SeqString(&#39;&#39;.join(self.data[pos:end])) def concat_string(self, other_str): """连接两个: 首尾相接""" return SeqString(&#39;&#39;.join(self.data) + &#39;&#39;.join(other_str.data)) # 测试示例 (基于引用[^1]的实验内容) if __name__ == "__main__": s = SeqString("abcdefghijklmn") # 建立s s1 = SeqString("123") # 建立s1 print("输出s:", end=" "); s.print_string() print("s长度:", s.get_length()) s2 = s.insert_string(s1.data, 8) # 在第9字符位置插入 (索引从0开始) print("插入后s2:", end=" "); s2.print_string() s2 = s.delete_substring(1, 3) # 删除第2字符开始的3字符 print("删除后s2:", end=" "); s2.print_string() s2 = s.replace_substring(s1.data, 1, 5) # 替换第2字符开始的5字符 print("替换后s2:", end=" "); s2.print_string() s3 = s.substring(1, 10) # 提取第2字符开始的10字符 print("s3:", end=" "); s3.print_string() s4 = s.concat_string(s1) # 连接s1和s print("连接后s4:", end=" "); s4.print_string() ``` 这个实现覆盖了引用[^1]中描述的所有操作。顺序串的优势是随机访问快(时间复杂度 $O(1)$),但插入和删除操作需移动大量元素,效率较低。在实际应用中,可根据需求优化存储结构[^1]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值