华为OD机试 - 查找字符串中相同字符连续出现的最大次数 - 线性扫描（Python/JS/C/C++ 2025 B卷 100分）

2025B卷华为OD机试统一考试题库清单（持续收录中）以及考点说明（Python/JS/C/C++）。

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。

一、题目描述

输入一串字符，字符串长度不超过 100，查找字符串中相同字符连续出现的最大次数。

二、输入描述

输入只有一行，包含一个长度不超过100的字符串。

三、输出描述

输出只有一行，输出相同字符连续出现的最大次数。

说明：字符串区分大小写

四、测试用例

测试用例1：

1、输入

hello

2、输出

2

3、说明

测试用例2：

1、输入

word

2、输出

1

3、说明

测试用例3：

1、输入

aaabbcc

2、输出

3

3、说明

五、解题思路

1、具体步骤

1. 通过 Scanner 读取用户输入的一行字符串。
2. 检查输入字符串是否为空。如果为空，则最大连续次数为0，直接输出并结束。
3. 如果字符串非空，初始化两个整数变量：
   • maxCount：用于存储迄今为止发现的最大连续字符次数，初始值为1（因为非空字符串至少有一个字符，其连续次数至少为1）。
   • currentCount：用于存储当前正在计算的连续字符次数，初始值为1。
     遍历字符串：从字符串的第二个字符（索引为1）开始，逐个字符向后遍历，直到字符串末尾。

比较与计数：在每次迭代中，将当前字符与其前一个字符进行比较：

如果相同：说明连续序列仍在继续，将 currentCount 加1。

如果不同：说明前一个字符的连续序列已经结束。此时，将 currentCount 重置为1（因为当前字符是新序列的开始）。

更新最大值：在每次迭代（无论当前字符是否与前一个相同），都将 maxCount 更新为 maxCount 和 currentCount 中的较大值。这样做可以确保 maxCount 总是记录到目前为止遇到的最长连续序列的长度。

输出结果：遍历完成后，maxCount 中存储的就是整个字符串中相同字符连续出现的最大次数。将其输出。

2、数据结构与算法

采用线性扫描/迭代，算法的核心是通过一次遍历（从字符串的第二个字符开始，比较当前字符和前一个字符）来处理整个字符串。

在遍历过程中，使用 currentCount 来跟踪当前连续相同字符的长度，并将其与 maxCount 进行比较，以动态更新所找到的最大连续次数。

线性扫描算法的时间复杂度为 O(N)，其中 N 是字符串的长度。对于题目中长度不超过100的字符串，这种时间复杂度非常高效。

六、Python算法源码

# 读取输入的一行字符串
s = input()

# 检查字符串是否为空
if not s: # Python中空字符串布尔值为False
    # 如果为空，则输出0
    print(0)
else:
    # 初始化最大连续字符次数（因为字符串非空，至少为1）
    max_count = 1
    # 初始化当前连续字符次数
    current_count = 1
    # 从字符串的第二个字符开始遍历（索引从1到len(s)-1）
    for i in range(1, len(s)):
        # 如果当前字符 s[i] 与前一个字符 s[i-1] 相同
        if s[i] == s[i-1]:
            # 增加当前连续次数
            current_count += 1
        else:
            # 如果当前字符与前一个字符不同
            # 重置当前连续次数为1（因为是新的字符序列的开始）
            current_count = 1
        # 每次迭代都尝试更新最大连续次数
        # max() 函数返回参数中的最大值
        max_count = max(max_count, current_count)
    # 输出计算得到的最大连续字符次数
    print(max_count)

七、JavaScript算法源码

// JavaScript 通常在 Node.js 环境中使用 readline 模块来处理控制台行输入
const readline = require('readline'); // 引入 readline 模块

// 创建 readline 接口实例
const rl = readline.createInterface({
    input: process.stdin,  // 设置输入流为标准输入
    output: process.stdout, // 设置输出流为标准输出 (本例中未使用, console.log直接输出)
    terminal: false        // 声明为非交互式终端，确保单行输入能正确处理
});

// 监听 'line' 事件，当读取到一行输入时触发回调函数
rl.on('line', (s) => { // s 是读取到的字符串行
    // 检查字符串是否为 null (理论上readline不会给null) 或空 (长度为0)
    if (!s || s.length === 0) {
        // 如果为空，则输出0
        console.log(0);
    } else {
        // 初始化最大连续字符次数（因为字符串非空，至少为1）
        let maxCount = 1;
        // 初始化当前连续字符次数
        let currentCount = 1;

        // 从字符串的第二个字符开始遍历（索引从1开始）
        for (let i = 1; i < s.length; i++) {
            // 如果当前字符 s[i] 与前一个字符 s[i-1] 相同
            if (s[i] === s[i-1]) { // 使用严格相等 ===
                // 增加当前连续次数
                currentCount++;
            } else {
                // 如果当前字符与前一个字符不同
                // 重置当前连续次数为1（因为是新的字符序列的开始）
                currentCount = 1;
            }
            // 每次迭代都尝试更新最大连续次数
            // Math.max 返回参数中的最大值
            maxCount = Math.max(maxCount, currentCount);
        }
        // 输出计算得到的最大连续字符次数
        console.log(maxCount);
    }
    rl.close(); // 处理完一行输入后关闭 readline 接口，对于单行输入问题
});

八、C算法源码

#include <stdio.h>  // 引入标准输入输出库 (for printf, fgets)
#include <string.h> // 引入字符串处理库 (for strlen, strcspn)

// 自定义一个简单的 max 函数，因为 C 标准库没有直接的 int max(int, int)
int max(int a, int b) {
    return (a > b) ? a : b; // 返回 a 和 b 中较大的一个
}

int main() {
    char s[102]; // 声明一个字符数组来存储字符串, 长度不超过100, +1 for '\0', +1 for potential newline

    // 从标准输入读取一行字符串，fgets 最多读取 sizeof(s)-1 个字符或直到换行符
    if (fgets(s, sizeof(s), stdin) == NULL) {
        // 如果 fgets 返回 NULL (例如遇到文件尾或错误)，视为空输入
        printf("0\n"); // 输出0
        return 0;      // 程序结束
    }

    // fgets 会读取并存储换行符（如果行长度小于缓冲区大小）
    // 使用 strcspn 找到第一个换行符的索引，并将其替换为字符串终止符 '\0'
    s[strcspn(s, "\n")] = '\0';

    int len = strlen(s); // 获取处理后字符串的实际长度

    if (len == 0) { // 检查字符串是否为空 (例如，用户只输入了一个回车)
        printf("0\n"); // 如果为空，则输出0
        return 0;     // 正常结束程序
    }

    int maxCount = 1;     // 初始化最大连续字符次数（因为字符串非空，至少为1）
    int currentCount = 1; // 初始化当前连续字符次数

    // 从字符串的第二个字符开始遍历（索引从1开始）
    for (int i = 1; i < len; i++) {
        if (s[i] == s[i-1]) { // 如果当前字符与前一个字符相同
            currentCount++;      // 增加当前连续次数
        } else { // 如果当前字符与前一个字符不同
            // 重置当前连续次数为1（因为是新的字符序列的开始）
            currentCount = 1;
        }
        // 每次迭代都尝试更新最大连续次数
        maxCount = max(maxCount, currentCount); // 使用自定义的max函数
    }

    printf("%d\n", maxCount); // 输出计算得到的最大连续字符次数
    return 0; // 正常结束程序
}

九、C++算法源码

#include <iostream> // 引入输入输出流库 (for std::cin, std::cout)
#include <string>   // 引入字符串库 (for std::string)
#include <algorithm> // 引入算法库 (for std::max)

int main() {
    // 可选: 这两行用于加速 C++ 的 cin/cout 操作，在处理大量输入输出时有用
    std::ios_base::sync_with_stdio(false); // 关闭 C++ 流与 C 标准IO的同步
    std::cin.tie(NULL);                   // 解除 cin 与 cout 的绑定

    std::string s;    // 声明一个 std::string 对象来存储字符串
    std::getline(std::cin, s); // 从标准输入读取一整行字符串 (包括空格) 到 s

    if (s.empty()) { // 检查字符串是否为空 (s.empty() 比 s.length() == 0 更常用)
        std::cout << 0 << std::endl; // 如果为空，则输出0 (std::endl 会输出换行并刷新缓冲区)
        return 0; // 正常结束程序
    }

    int maxCount = 1;     // 初始化最大连续字符次数（因为字符串非空，至少为1）
    int currentCount = 1; // 初始化当前连续字符次数

    // 从字符串的第二个字符开始遍历（索引从1开始）
    // s.length() 返回类型是 size_t，通常用 size_t 作为循环变量类型
    for (size_t i = 1; i < s.length(); ++i) {
        if (s[i] == s[i-1]) { // 如果当前字符与前一个字符相同
            currentCount++;      // 增加当前连续次数
        } else { // 如果当前字符与前一个字符不同
            // 重置当前连续次数为1（因为是新的字符序列的开始）
            currentCount = 1;
        }
        // 每次迭代都尝试更新最大连续次数
        maxCount = std::max(maxCount, currentCount); // 使用 std::max (在 <algorithm> 中)
    }

    std::cout << maxCount << std::endl; // 输出计算得到的最大连续字符次数
    return 0; // 正常结束程序
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2025 B卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。