数据结构串 Python

图片上第8，9，10（1）
用Python语言设计算法
（这里都是废话，凑字数的，哈哈）

第8题：

def max_character_count(s):
    char_count = {}
    max_count = 0

    for c in s:
        if c in char_count:
            char_count[c] += 1
        else:
            char_count[c] = 1

        if char_count[c] > max_count:
            max_count = char_count[c]

    return max_count

# 示例用法
s = "aabbccddeeffggddeeffggffgg"
max_count = max_character_count(s)
print("最大字符出现的次数:", max_count)

第9题：

def remove_substring(s):
    target = "abc"  # 目标子串
    target_length = len(target)
    result = ""
    index = 0

    while index < len(s):
        if s[index:index+target_length] == target:
            index += target_length
        else:
            result += s[index]
            index += 1

    return result

# 示例用法
s = "ababcababcababc"
result = remove_substring(s)
print("删除子串后的结果:", result)

第10(1)题：
BF算法即暴力匹配算法，其执行过程如下：
从 i=0, j=0 开始，逐个比较 s[i] 和 t[j] 的字符，如果字符匹配，则同时将 i 和 j 加1，继续比较下一个字符；如果字符不匹配，将 i 回溯到上一次比较的起始位置的下一个位置（即 i=i-j+1），j 重置为0，重新开始匹配。
当成功匹配整个子串 t 时，记录此时的最后一次出现位置（即 i-len(t)）。然后重复之前的步骤，直到遍历完整个串 s。

def last_occurrence(s, t):
    i = 0
    j = 0
    last_index = -1

    while i < len(s):
        if s[i] == t[j]:
            i += 1
            j += 1
            if j == len(t):
                last_index = i - len(t)
                j = 0
        else:
            i = i - j + 1
            j = 0

    return last_index

# 示例用法
s = "abcdabcda"
t = "abc"
last_index = last_occurrence(s, t)
print("子串最后一次出现的位置:", last_index)

你可以看下这个问题的回答https://ask.csdn.net/questions/7799846
这篇博客也不错, 你可以看下Python全栈（二）数据结构和算法之6.队列的实现和冒泡排序的实现
除此之外, 这篇博客: Python算法图解——递归（二）：打印从10循环到1中的 Python算法图解——递归（二）：打印从10循环到1 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
本系列内容来自何韬编著的《Python算法图解》。
递归：程序调用自身的编程技巧。
它通常把一个大型复杂的问题,层层转换为一个与原问题相似的规模较小的问题来求解。
在某些情况下,它能解决 for 循环难以解决的算法问题,有时只需少量的代码就可描述出解题过程所需要的多次重复计算,大大减少了代码量。
在程序实现中,递归往往以调用的方式存在。
递归调用：声明一个方法,并在这个方法中设定条件,在此条件下调用自身方法,也就是在方法中自己调用自己,如果不符合条件则停止调用。
```
# 打印：从10循环到1
def F(x):
    if x >= 1:
        print(x)
        F(x-1)
F(10)
```
```
10
9
8
7
6
5
4
3
2
1
```
但是如果函数的输入指定只能为1呢？
```
def F(x):
    if x <= 10:
        F(x+1)  # 这样，只有当输入为10的时候，才能跳出这个F(x+1)
        print(x)
F(1)
```
```
10
9
8
7
6
5
4
3
2
1
```
上面这个的思想就是，当输入<10时，就一直会进入if循环中，直到输入为11（即x+1）的时候，在F(11)中，不满足 x <= 10 的条件，不进入if函数，那么F(x+1)在这里就结束了，即F(11)这个循环结束，那么到了倒数第二层F(10)的循环，print(10)。
输出了10以后，F(10)结束，接着的倒数第三层的F(9)中的print(9)。
其实上面这个函数就是打印从10到x的数字。
我们可以用F(9)来举例：
```
F(9)
```
```
10
9
```
这是因为，F(9)中包含了F(10)和print(9)，F(10)的结果是print(10)，所以依次执行的就是print(10)和print(9)。
接下来也同理：
F(8)中包含了F(9)和print(8)，而里面的F(9)又包含了F(10)和print(9)，以此类推……
您还可以看一下 CSDN就业班老师的 Python全栈工程师特训班第十三期-直播回放课程中的 Python全栈工程师特训班第十三期-运维第二周 9小节, 巩固相关知识点
以下回答由chatgpt基于相关博客总结生成:
我可以提供一个使用Python实现的字符串类，代码如下：
class String: def init(self, s): self.s = s
```
def __len__(self):
    return len(self.s)

def __str__(self):
    return self.s

def __repr__(self):
    return self.s

def __getitem__(self, i):
    if isinstance(i, slice):
        return String(self.s[i])
    else:
        return self.s[i]

def __add__(self, other):
    return String(self.s + other.s)

def __mul__(self, n):
    return String(self.s * n)
```
这个类支持切片，算术运算（+ 和 *），以及像长度和下标访问这样的常规操作。你可以使用这个类来构建和操作字符串。
需要注意的是，这个类是基于Python内置字符串类型的，因此并不是一个真正的“数据结构中的串”。但是我们可以将这个类作为学习资料和参考使用，懂得了Python的字符串操作，就能够更好地理解和应用其他编程语言中的字符串。

数据结构 串 Python

数据结构串 Python