第八周项目3-顺序串算法

采用顺序存储方式存储串,实现下列算法并测试: 
(1)试编写算法实现将字符串S中所有值为c1的字符换成值为c2的字符: 
void Trans(SqString *&s, char c1, char c2); 
(2)试编写算法,实现将已知字符串所有字符倒过来重新排列。如ABCDEF改为FEDCBA。 
void Invert(SqString &s) 
(3)从串s中删除其值等于c的所有字符。如从message中删除’e’,得到的是mssag。 
void DellChar(SqString &s, char c) 
(4)有两个串s1和s2,设计一个算法求一个这样的串,该串中的字符是s1和s2中公共字符。所谓公共子串,是由在s1中有,且在s2中也有的字符构成的字符。例s1为”message”,s2为”agent”,得到的公共子串是”eage”。 
SqString CommChar(SqString s1,SqString s2);

(1)试编写算法实现将字符串S中所有值为c1的字符换成值为c2的字符: 
void Trans(SqString *&s, char c1, char c2); 

参考:

#include <stdio.h>
#include "sqString.h"
void Trans(SqString &s, char c1, char c2)
{
    int i;
    for (i=0; i<s.length; i++)
        if (s.data[i]==c1)
            s.data[i]=c2;
}

int main()
{
    SqString s;
    StrAssign(s, "messages");
    Trans(s, 'e', 'a');
    DispStr(s);
    return 0;
}

(2)试编写算法,实现将已知字符串所有字符倒过来重新排列。如ABCDEF改为FEDCBA。 
void Invert(SqString &s)

参考: 
将字符串中的第一个元素与最后一个元素进行交换,第二个元素与倒数第二个元素进行交换,以此类推,将所有的字符进行交换,最后将字符串反序。

#include <stdio.h>
#include "sqString.h"
void Invert(SqString &s)
{
    int i;
    char temp;
    for (i=0; i<s.length/2; i++)
    {
        temp = s.data[i];
        s.data[i]=s.data[s.length-i-1];
        s.data[s.length-i-1] = temp;
    }
}

int main()
{
    SqString s;
    StrAssign(s, "abcdefg");
    Invert(s);
    DispStr(s);
    return 0;
}

(3)从串s中删除其值等于c的所有字符。如从message中删除’e’,得到的是mssag。 
void DellChar(SqString &s, char c)

参考:从头到尾扫描s串,对于其值为c的元素采用移动的方式进行删除。

#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;
    StrAssign(s, "message");
    DellChar(s, 'e');
    DispStr(s);
    return 0;
}

(4)有两个串s1和s2,设计一个算法求一个这样的串,该串中的字符是s1和s2中公共字符。所谓公共子串,是由在s1中有,且在s2中也有的字符构成的字符。例s1为”message”,s2为”agent”,得到的公共子串是”eage”。 
SqString CommChar(SqString s1,SqString s2);

参考:对于s1中的每一个字符,查看在s2中是否出现,如果出现,则加到结果字符串中。

#include <stdio.h>
#include "sqString.h"

SqString CommChar(SqString s1,SqString s2)
{
    SqString s3;
    int i,j,k=0;
    for (i=0; i<s1.length; i++)
    {
        for (j=0; j<s2.length; j++)
            if (s2.data[j]==s1.data[i])
                break;
        if (j<s2.length)            //s1.data[i]是公共字符
        {
            s3.data[k]=s1.data[i];
            k++;
        }
    }
    s3.length=k;
    return s3;
}

int main()
{
    SqString s1, s2, s;
    StrAssign(s1, "message");
    StrAssign(s2, "agent");
    s = CommChar(s1, s2);
    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、付费专栏及课程。

余额充值