找第一个只出现一次的字符

所属作业: hw5 数据结构: 列表, 字典 算法: 循环

两重循环,第一重循环去枚举字符s[i],第二重循环检查s[i]是否只出现了一次。时间复杂度O(n*n),n是字符串长度。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 接收输入的字符串
s = input()
# 初始化答案为 "no",表示默认没有找到仅出现一次的字符
answer = "no"

# 外层循环遍历字符串的每个字符
for i in range(0, len(s)):
    # 假设当前字符是唯一的
    flag = True
    # 内层循环遍历字符串的每个字符
    for j in range(0, len(s)):
        # 如果当前字符不是自己,并且与其他字符相同
        if i != j and s[i] == s[j]:
            # 将flag设为False,表示当前字符不是唯一的
            flag = False
            break  # 跳出内层循环

    # 如果flag仍然为True,说明当前字符是唯一的
    if flag:
        answer = s[i]  # 更新答案为当前字符
        break  # 找到第一个唯一字符后跳出外层循环

# 输出结果,如果没有找到唯一字符则输出"no"
print(answer)

两重循环,第一重循环去枚举字符s[i],第二重循环检查s[i]是否只出现了一次。由于我们是从第i个位置向前向后枚举第一个和s[i]相同的字符,第二重循环均摊复杂度是O(26),所以总时间复杂度O(n),n是字符串长度。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 接收输入的字符串
s = input()

# 初始化答案为 "no",表示默认没有找到仅出现一次的字符
answer = "no"

# 遍历字符串中的每一个字符
for i in range(0, len(s)):
    # 假设当前字符是唯一的,设置标志为 True
    flag = True
    
    # 检查当前字符在它之前的字符中是否出现过
    for j in range(i - 1, -1, -1):
        if s[i] == s[j]:  # 如果当前字符与之前的字符相同
            flag = False  # 标志设为 False,表示不是唯一字符
            break  # 退出内层循环
    
    # 检查当前字符在它之后的字符中是否出现过
    for j in range(i + 1, len(s), 1):
        if s[i] == s[j]:  # 如果当前字符与之后的字符相同
            flag = False  # 标志设为 False,表示不是唯一字符
            break  # 退出内层循环
    
    # 如果标志仍然为 True,表示当前字符是唯一的
    if flag:
        answer = s[i]  # 将答案更新为当前字符
        break  # 找到第一个唯一字符后,退出外层循环

# 输出结果,如果没有找到唯一字符,则输出 "no"
print(answer)

字典做法,用 char_count 统计字符出现次数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
# 接收输入的字符串
s = input()

# 创建一个字典来记录每个字符的出现次数
char_count = {}

# 遍历字符串,统计每个字符的出现次数
for char in s:
    if char in char_count:
        char_count[char] += 1
    else:
        char_count[char] = 1

# 遍历字符串,寻找第一个仅出现一次的字符
for char in s:
    if char_count[char] == 1:  # 如果字符的出现次数为 1
        print(char)  # 输出该字符
        break  # 找到后退出循环
else:
    print("no")  # 如果没有找到,输出 "no"

这种方法的时间复杂度是 O(n),因为我们只需要遍历字符串两次,效率更高,适合处理较大的输入。