【免费下载链接】InterviewGuide
🔥🔥「InterviewGuide」是阿秀从校园->职场多年计算机自学过程的记录以及学弟学妹们计算机校招&秋招经验总结文章的汇总,包括但不限于C/C++ 、Golang、JavaScript、Vue、操作系统、数据结构、计算机网络、MySQL、Redis等学习总结,坚持学习,持续成长!
本篇技术指南以 InterviewGuide 开源仓库中《精选力扣300+题目》的字符串分类为骨架,完整整理了该专题下 Easy 与 Medium 两个难度等级的 11 道高频字符串算法题:每道题都附有完整题目描述、示例与可运行的 C++ 题解,并逐题拆解哈希表映射、双指针、流式分词、方向翻转模拟、溢出防护等核心技巧。读完本文,你将获得一套面向互联网求职笔试/面试的字符串题型解题方法论,并能直接按题目链接跳转到仓库对应文档查看原始笔记。
专题背景与使用方式
字符串是互联网校招与社招笔试面试中的绝对高频考点,其考察点横跨哈希表、双指针、动态规划、模拟与边界条件处理等多个维度。InterviewGuide 仓库在《精选力扣300+题目》专栏下按照 13 个标签对算法题进行了系统化分类,字符串是其中独立成册的一个大类,入口文档位于 字符串专题目录。
该目录与仓库算法模块的整体结构保持一致,采用 Easy / Medium / Hard 三级难度分级:
- Easy(7 题):13. 罗马数字转整数、67. 二进制求和、434. 字符串中的单词数、819. 最常见的单词、859. 亲密字符串、686. 重复叠加字符串匹配、680. 验证回文字符串 Ⅱ;
- Medium(5 题):6. Z 字形变换、8. 字符串转换整数(atoi)、17. 电话号码的字母组合、165. 比较版本号、5461. 仅含 1 的子串数;
- Hard:目录中暂未收录 Hard 难度题目,
total/02-字符串/hard.md同样为空文件,说明字符串分类的难题以独立题解形式散落在仓库其他模块中。
在仓库中,每道题均有独立的题解文档(位于 easy/ 与 medium/ 子目录),并同步存在一个汇总版本目录 total/02-字符串/(含 easy.md、medium.md),方便读者按难度整体翻阅。如果你不清楚自己应该按什么顺序刷题,可以先阅读算法模块使用指南与精选力扣300+题目总览,再按本文给出的顺序逐个击破。
一、Easy 篇:边界条件与基础技巧的集中训练
Easy 难度看似简单,实则是边界条件处理能力的最佳训练场。以下 7 道题分别覆盖了字符串题最基础的几类解法。
1. 13. 罗马数字转整数(哈希表映射 + 顺序特判)
题解文档:easy/13.罗马数字转整数.md
罗马数字包含以下七种字符:
| 字符 | 数值 |
|---|---|
| I | 1 |
| V | 5 |
| X | 10 |
| L | 50 |
| C | 100 |
| D | 500 |
| M | 1000 |
通常情况下,罗马数字中小的数字在大的数字的右边,例如 2 写作 II、12 写作 XII、27 写作 XXVII。但也存在 4 不写作 IIII 而写作 IV 的特例——数字 1 在数字 5 的左边,表示大数 5 减小数 1。该特殊规则仅适用于六种情况:
I可放在V(5) 和X(10) 左边,表示 4 和 9;X可放在L(50) 和C(100) 左边,表示 40 和 90;C可放在D(500) 和M(1000) 左边,表示 400 和 900。
输入确保在 1 到 3999 的范围内。示例:"III" → 3;"IV" → 4;"IX" → 9;"LVIII" → 58;"MCMXCIV" → 1994(M=1000, CM=900, XC=90, IV=4)。
仓库笔记给出的第一版解法用 unordered_map<char,int> 建立字符到数值的映射,然后从左到右扫描,遇到 I、X、C 三个"可前置"字符时,先检查后一位是否构成 4/9、40/90、400/900 的特例,命中则累加组合值并跳过一位:
int romanToInt(string s) {
unordered_map<char, int> nums = { {'I',1},{'V',5},{'X',10},{'L',50},{'C',100},{'D',500},{'M',1000} };
int sum = 0, len = s.size();
for (int i = 0; i < len; ++i) {
if (s[i] == 'I') {
if (i<len-1&&s[i+1] == 'V') { sum += 4; i++; } //千万注意i要小于len-1才可以,注意不要越界
else if (i < len - 1 && s[i+1] == 'X') {
sum += 9;
i++;
}
else
sum += 1;
} else if (s[i] == 'X') {
if (i < len - 1 && s[i+1] == 'L') { sum += 40; i++; }
else if (i < len - 1 && s[i+1] == 'C') {
sum += 90;
i++;
}
else
sum += 10;
}else if (s[i] == 'C') {
if (i < len - 1 && s[i+1] == 'D') { sum += 400; i++; }
else if (i < len - 1 && s[i+1] == 'M') {
sum += 900;
i++;
}
else
sum += 100;
}
else if (s[i] == 'V') sum += 5;
else if (s[i] == 'L') sum += 50;
else if (s[i] == 'D') sum += 500;
else if (s[i] == 'M') sum += 1000;
}
return sum;
}
易错点:核心坑位在于数组越界。访问 s[i+1] 前必须确保 i < len-1,否则当 I/X/C 出现在字符串末尾时会读取越界字符。这也是原笔记中反复强调"千万注意 i 要小于 len-1 才可以"的原因。
进阶思路(面试加分项):可以简化为"遍历每个字符,若当前字符数值小于右边相邻字符数值,则减去当前值,否则加上当前值",只需一次遍历即可覆盖全部 6 种特例,无需逐一分支判断。
2. 67. 二进制求和(字符串模拟加法)
题解文档:easy/67.二进制求和.md
给定两个二进制字符串,返回它们的和(用二进制表示),输入为非空且只含数字 1 和 0。示例:a="11", b="1" → "100";a="1010", b="1011" → "10101"。
仓库笔记给出的解法采用**"反转 + 逐位进位"**的思路:
- 先将两个字符串
reverse,使低位对齐,方便从最低位开始处理; - 把较短的串补到较长串的对应位上,逐位累加为字符(
b[i] - '0' + a[i]); - 从低位向高位扫描,遇到
>= '2'的位就进位(除以 2 加到下一位,自身取模 2); - 最后反转回来,若最高位仍大于
'1',则减去 2 并前置一个'1'。
string addBinary(string a, string b) {
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
if (a.size() < b.size()) swap(a, b);
vector<char> res;
int len = b.size(),minus = a.size()-b.size();
for (int i = 0; i <len; ++i) {
res.push_back(b[i] - '0' + a[i]);
}
for (int i = len; i < len+minus; ++i)
res.push_back(a[i]);
for (int i = 0; i <len+minus-1; ++i) {
if (res[i] >= '2') {
res[i + 1] = res[i + 1] + (res[i] - '0')/2;
res[i] = '0' + (res[i] -'0') % 2;
}
}
string result;
for (auto& a : res)
result += a;
reverse(result.begin(), result.end());
if (result[0] > '1') {
result[0] = result[0] -2;
result = '1' + result;
}
return result;
}
技巧提炼:二进制加法与十进制加法在"进位"逻辑上完全同构,区别仅在模数(2 与 10)。面试时也可以直接用 carry 变量从末位往前扫,一次循环完成相加与进位,代码更简洁、可读性更好,这是值得对比实现的第二种写法。
3. 434. 字符串中的单词数(stringstream 流式分词)
题解文档:easy/434.字符串中的单词数.md
统计字符串中单词个数,这里的"单词"指连续的非空格字符序列,可假定字符串不含不可打印字符。示例:"Hello, my name is John" → 5。
仓库笔记给出了两个版本。第一版手动遍历,用 word 累积当前单词,遇空格且 word 非空则计数并清空:
int countSegments(string s) {
int cut = 0;
string word;
for (auto& a : s) {
if (a == ' ' && word != "") {
cut++;
word = "";
}
else if (a == ' ' && word == "") continue;
else
{
word += a;
}
}
if (word != "") cut++;
return cut;
}
第二版则利用 stringstream 以空格为分隔符自动分词,代码量大幅缩减,是 C++ 字符串处理中非常实用的一招:
int countSegments(string s) {
string str;
int count = 0;
stringstream ss;
ss << s;
while (ss >> str)
count ++;
return count;
}
技巧提炼:stringstream 的 >> 运算符天然以空白符(空格、制表符、换行)作为分隔符提取 token,处理"按空格分词并计数"类问题时比手写状态机更简洁安全。需要同时掌握手动遍历版本,因为部分面试场景要求不使用流操作。
4. 819. 最常见的单词(大小写归一化 + 哈希计数 + 禁用词过滤)
题解文档:easy/819.最常见的单词.md
给定段落 paragraph 与禁用词列表 banned,返回出现次数最多且不在禁用列表中的单词。段落中单词不区分大小写,标点符号(!?',;.)需要忽略(即使紧挨单词,如 "ball,"),答案唯一且全为小写。示例:paragraph = "Bob hit a ball, the hit BALL flew far after it was hit.",banned = ["hit"] → 输出 "ball"。
仓库笔记记录了三个版本的迭代过程,这本身就是一个很好的"从有 bug 到最优"的复盘案例:
- 第一版有缺陷:仅在
paragraph[i] == ' '时结算单词,忽略了逗号、句号等标点。用用例"a, a, a, a, b,b,b,c, c"与["a"]测试时,输出"bbbc"而非预期的"b",因为b,b,b被粘连成了bbb整体计数。 - 第二版修正:把"仅空格结算"改为"遇到非字母字符且
word非空即结算",同时保留大写转小写逻辑,从而正确处理所有标点分隔符:
string mostCommonWord(string paragraph, vector<string>& banned) {
string word;
int len=paragraph.size(),max=1;
unordered_map<string, int> res;
for (auto &p:paragraph) {
if (p >= 'A' && p <= 'Z') word += p + 'a' - 'A';
else if (p >= 'a' && p <= 'z') word += p;
else if(word!="")
{
if (find(banned.begin(), banned.end(), word) == banned.end()) {
res[word] += 1;
}
word = "";
}
}
for (auto &a : res) {
if (max <= a.second) {
max = a.second;
word = a.first;
}
}
return word;
}
- 第三版:把遍历方式从
for (auto &p : paragraph)改为for (auto p : paragraph)(按值复制),仓库笔记记录其执行时间反而更快(4ms,击败 98.99% 用户),作者本人也标注"有点不可思议"。
易错点复盘:本地的核心 bug 是分词边界判断不完整——只认空格不认标点。这说明字符串分词题必须明确"单词的终止条件"到底是哪些字符,建议把所有非字母字符(空格 + 标点 + 数字)统一视为分隔符。另外禁用词判断可用 unordered_set 将查找从 O(n) 降到 O(1),面试时可主动优化。
5. 859. 亲密字符串(分类讨论 + 错误解法复盘)
题解文档:easy/859.亲密字符串.md
给定两个由小写字母构成的字符串 A 和 B,若可通过交换 A 中的两个字母得到与 B 相等的结果,返回 true,否则返回 false。
| 示例 | 输入 | 输出 | 说明 |
|---|---|---|---|
| 1 | A="ab", B="ba" | true | 交换 a、b 即可 |
| 2 | A="ab", B="ab" | false | 必须交换恰好两个位置 |
| 3 | A="aa", B="aa" | true | 交换两个相同字符 |
| 4 | A="aaaaaaabc", B="aaaaaaacb" | true | 交换 b、c |
| 5 | A="", B="aa" | false | 长度不同 |
提示:0 <= A.length, B.length <= 20000,仅含小写字母。
仓库笔记首先给出一个错误的第一版——它用 unordered_set 记录相同位置的字符,仅凭 res.size() == 1 就返回 true,逻辑存在漏洞:它无法正确区分"恰好两个位置不匹配"与"存在重复字符"两类情况,也无法处理 A="ab", B="ab" 这类"没有可交换位置却恰好相等"的用例。这种"先写错再修正"的记录方式对读者极具价值——面试时写出正确解的前提,是先想清楚所有边界分支。
第二版(正确解法)的核心是分类讨论,仅三种情况:
- 长度不同或长度小于 2,直接返回
false; - 不匹配的位置超过 2 个,返回
false(一次交换最多只影响两个位置); - 若完全不匹配(
res.size()==0),说明A==B,此时只要A中存在重复字符即可交换两个相同字符得到相同结果; - 否则(恰好 2 处不匹配),判断这两处字符交换后是否相等。
bool buddyStrings(string A, string B) {
if (A.size() != B.size() || A.size()<2) return false;
int len = A.size();
vector<int> res;
res.reserve(len);
for (int i = 0; i < len; ++i) {
if (A[i] != B[i]) {
res.push_back(i);
if (res.size() > 2) return false;
}
}
if (res.size() == 0) {
unordered_set<char> misMatch(A.begin(), A.end());
return misMatch.size() < len;
}
return A[res[0]] == B[res[1]] && A[res[1]] == B[res[0]];
}
技巧提炼:本题的难点不是算法,而是边界分类的完备性——"完全相等但有重复字符"这一分支极易遗漏。unordered_set<char> misMatch(A.begin(), A.end()) 判断去重后元素个数是否小于原长度,是检测"是否存在重复字符"的经典一行写法。
6. 686. 重复叠加字符串匹配(find 定位 + 叠加次数分析)
给定字符串 A 和 B,寻找重复叠加 A 的最小次数,使得 B 成为叠加后字符串的子串,若不存在返回 -1。例如 A="abcd",B="cdabcdab":叠加两遍为 "abcdabcd" 不包含 B,叠加三遍为 "abcdabcdabcd" 才包含,答案为 3。注意 A 与 B 的长度在 1 到 10000 之间。
仓库笔记给出的解法非常精妙,只需分析两种可能:
- 先把
T叠加到长度 >=B.size(),此时若T.find(B) != npos,直接返回叠加次数(覆盖"顺序增长"的情况,如abcd与abcdabcdabcd); - 若仍未命中,再叠加一次
A后查找(覆盖"跨越边界"的情况,如abcd与cdabcdabcdabcdab——B 的开头部分在叠加串尾部,结尾部分在下一段开头);仍找不到则返回 -1。
if (A.empty()) {
return -1;
}
string T = A;
int i = 1;
while (T.size() < B.size()) {
T.append(A);
++i;
}
//A的长度大于等于B了
if (T.find(B) != string::npos) {//顺序增长的就可以了,比如abcd 和 abcdabcdabcd
return i;
}
T.append(A);
++i;
if (T.find(B) != string::npos) { //不是按序增长,比如abcd 和 cdabcdabcdabcdab
return i;
}
return -1;
原理分析:为什么最多只需"长度达到 B 后再叠加一次"?因为 B 若由若干段 A 拼接而成,其起点最多落在某一遍 A 的内部,因此完整覆盖 B 所需的叠加次数不超过 ceil(B.len / A.len) + 1。仓库笔记将其总结为"顺序增长"与"非按序增长"两类情况,边界分析非常干净,值得背诵。若追求更优复杂度,可在此基础上改用 KMP 匹配,将 find 的 O(n·m) 降为 O(n+m)。
7. 680. 验证回文字符串 Ⅱ(双指针 + 最多删除一个字符)
题解文档:easy/680.验证回文字符串Ⅱ.md
给定非空字符串 s,最多删除一个字符,判断其是否仍能成为回文字符串。字符串仅含 a-z 小写字母,最大长度 50000。示例:"aba" → true;"abca" → true(删除 c)。
仓库笔记记录了两种思路的对比,非常值得学习:
- 第一版(错误思路):从中间向两端扩展(
equal函数以中点向两侧比对)。作者复盘指出"想差了,不应该用中间两端扩展法的"——原因在于中间扩展无法在第一次失配时快速定位"删左边还是删右边",且需要为奇偶长度分别处理中点,边界极易出错。 - 第二版(正确思路):从两端向中间进发,遇到首尾不相等时,分别尝试删除左侧字符或删除右侧字符,再判断剩余部分是否为回文,注意边界判断:
bool equal(string& s, int low, int high) {
while (low < high && s[low] == s[high]) {
low++;
high--;
}
return low >= high;
}
bool validPalindrome(string s) {
if (s.size() < 3) return true;
int low=0,high = s.size()-1;
while (s[low] == s[high]&&low < high) {
low++;
high--;
}
if (low == high || low-high==1) return true;
else if (equal(s, low+1, high) || equal(s, low, high-1))
return true;
else
return false;
}
技巧提炼:"从两端向中间收缩"是回文类问题的标准范式。遇到失配时,"删左"或"删右"的两种尝试通过逻辑或合并,天然覆盖了"最多删一个"的限制;equal(s, low+1, high) 对应删除左侧字符,equal(s, low, high-1) 对应删除右侧字符。全程 O(n) 时间、O(1) 额外空间,是该题的标准最优解。
二、Medium 篇:综合技巧与陷阱防御
Medium 题目在 Easy 的基础上叠加了更复杂的模拟、状态机与溢出防护要求。
1. 6. Z 字形变换(方向翻转模拟)
题解文档:medium/6.Z字形变换.md
将给定字符串按给定行数以从上往下、从左到右进行 Z 字形排列,再逐行读取产生新字符串。以 "LEETCODEISHIRING"、行数 3 为例:
L C I R
E T O E S I I G
E D H N
输出 "LCIRETOESIIGEDHN";行数 4 时输出 "LDREOEIIECIHNTSG"。
仓库笔记给出的解法本质是逐字符"走格子"的模拟:维护 curRow 与方向标志 goingDown,把每个字符追加到对应行;当 curRow 到达第 0 行或最后一行时,方向翻转:
string convert(string s, int numRows) {
if (numRows == 1) return s;
vector<string> rows(min(numRows, int(s.size()))); // 防止s的长度小于行数
int curRow = 0;
bool goingDown = false;
for (char c : s) {
rows[curRow] += c;
if (curRow == 0 || curRow == numRows - 1) {// 当前行curRow为0或numRows -1时,箭头发生反向转折
goingDown = !goingDown;
}
curRow += goingDown ? 1 : -1;
}
string res;
for (string row : rows) {// 从上到下遍历行
res += row;
}
return res;
}
两个关键细节:
- 特判
numRows == 1:只有一行时直接返回原串,避免方向翻转逻辑失效; - 行数取
min(numRows, int(s.size())):防止字符串长度小于行数导致数组越界。
第二版仅将 for (char c : s) 改为 for (char &c : s) 以省去拷贝,执行时间从 20ms 降到 16ms,是常见的引用遍历微优化。技巧提炼:方向翻转模拟可推广到一切"折返走位"类问题,核心是先判断"是否到达边界",再更新方向,最后移动游标。
2. 8. 字符串转换整数(atoi):四大陷阱与溢出防护
题解文档:medium/8.字符串转换整数.md
实现 atoi:丢弃开头空格直到首个非空格字符;若该字符为 +/- 则与后续连续数字组合成有符号整数;若为数字则直接组合;有效整数部分之后的字符可忽略。若首个非空格字符不是有效整数字符、字符串为空或全为空白,返回 0。假设环境只能存储 32 位有符号整数,超出范围返回 INT_MAX 或 INT_MIN。空白字符仅指空格 ' '。
关键示例:"42" → 42;" -42" → -42;"4193 with words" → 4193;"words and 987" → 0;"-91283472332" → -2147483648(超出范围)。
仓库笔记明确罗列了本题的四大陷阱,这是全文含金量最高的一段:
- 先判空:字符串长度为 0 直接返回,否则后续
str[i]访问越界; - 过滤空格与判断符号时同步检查索引:
while (i < len && str[i] == ' ') i++;,否则全空格字符串会越界访问; - 溢出判断必须在乘法之前:不能先算出结果再判断是否越界,因为计算本身已经溢出。应在
res = res * 10 + digit之前判断res是否已大于INT_MAX / 10; - 等于
INT_MAX/10时还需比较下一位:若res == INT_MAX / 10且下一位数字大于INT_MAX的最后一位(7),才判定溢出返回INT_MAX。
第一版虽然通过但存在未考虑清楚的情况——全空格输入会越界(while (str[i] == ' ') i++; 无长度保护,当字符串全为空格时 i 会走到 '\0' 处,属于未定义行为)。第二版补全了所有边界:
int myAtoi(string str) {
int len = str.size();
if (len == 0) return 0;//为空,直接返回即可
int i = 0, flag = 1,isSingal = 0;// 索引 正负号标志位 正负号出现次数
long res = 0; //默认flag = 1,正数
while (i<len && str[i] == ' ') i++; //若str全为空格,str[i] = '\0'(最后一个i)
if (i >= len) return 0;//全部都是空格,直接返回吧
if (i < len && str[i] == '-') { flag = -1; ++i; isSingal++; }
if (i < len && str[i] == '+') { ++i; ++isSingal; }
if (isSingal > 1) return 0;
for ( ; i < len && str[i]>='0' && str[i] <= '9'; ++i) {
res = res * 10 + (str[i] - '0');
if (res >= INT_MAX && flag == 1) return INT_MAX;
if (res > INT_MAX && flag == -1) return INT_MIN;
}
return flag * res;
}
进阶说明:仓库笔记的写法用 long res 承接中间值,再与 INT_MAX 比较,规避了 int 乘法溢出。但严格来说,笔记中提到的"加法之前先比较 INT_MAX/10"才是无 long 依赖的通用解法(尤其适用于禁止使用 64 位中间变量的面试场景),两种写法都值得掌握。技巧提炼:atoi 是状态机与溢出防护的经典考题,四大陷阱逐一落实后即可满分通过。
3. 17. 电话号码的字母组合(队列模拟 BFS 扩展)
给定仅含数字 2-9 的字符串,返回其所有能表示的字母组合(与电话按键映射一致,1 不对应字母)。示例:输入 "23",输出 ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。
仓库笔记第一版采用队列逐层扩展的思路:先把第一个数字对应的字母逐个入队,然后对后续每个数字,取出当前队列中所有元素,各自拼接上该数字对应的每个字母后重新入队,最终队列中即为全部组合:
vector<string> result;//用于输出向量
map<char, string> m = { {'2',"abc" },{'3',"def"},{'4',"ghi"},{'5',"jkl"},{'6',"mno"},{'7',"pqrs"},{'8',"tuv"},{'9',"wxyz"} };//映射map哈希表
int size = digits.size();//输入字符串产长度
queue<string> que;//新建队列
//先将第一个元素对应的码表入队
for (int j = 0; j < m[digits[0]].size(); j++)
{
string stemp;
stemp.push_back(m[digits[0]][j]);
que.push(stemp);//string入队
}
string s;//用于存储队头元素
for (int i = 1; i < size; i++)
{
int length = que.size();//当前队列长度
while (length--)
{
for (int j = 0; j < m[digits[i]].size(); j++)
{
s = que.front();
s = s + m[digits[i]][j];//队头元素加上新元素
que.push(s);//入队
}
que.pop();//队头出队
}
}
while (!que.empty())
{
result.push_back(que.front());//队头元素存储至res
que.pop();//队头出队
}
return result;//返回
第二版通过复用 stemp 并在每次入队后 clear(),避免重复构造字符串对象,略微节省空间(执行用时 0ms,击败 100% 用户)。
技巧提炼:队列版的本质是广度优先(BFS)的逐层扩展——每处理一个数字,就"乘"上该数字对应字母数。注意内层循环必须先记录 length = que.size(),否则在扩展过程中 que 不断入队,while 会无限扩展。本题亦可换用回溯(DFS)写法,面试时两种思路均应能流畅写出。
4. 165. 比较版本号(双指针按段比较 + 溢出隐患)
题解文档:medium/165.比较版本号.md
比较两个版本号 version1 与 version2:version1 > version2 返回 1,小于返回 -1,否则返回 0。版本字符串非空,只含数字和 .;. 用于分隔数字序列而非小数点;每级默认修订号为 0(如 3.4 的第三、四级修订号均为 0);数字串可能有前导零(1.01 与 1.001 相等)。
关键示例:"0.1" vs "1.1" → -1;"1.0.1" vs "1" → 1;"7.5.2.4" vs "7.5.3" → -1;"1.0" vs "1.0.0" → 0(缺失级别按 0 计)。
仓库笔记给出了三版递进写法,每一步都解决一个具体问题:
- 第一版:双指针按
.切段,逐段累加后比较,但存在两个缺陷:一是用sum1 = sum1 * 10 + temp把多段数字拼接而非累加,导致段数增多时sum持续膨胀,int 可能溢出(笔记专门贴出了一段长达数百段的超长版本号用例说明溢出场景);二是注释代码过多、逻辑混乱。 - 第二版:在每轮比较完毕后将
sum1、sum2重新置 0——"每次比较完毕,如果一样就可以置 0,再继续比较下去",避免数值无限累积,这是关键修复。 - 第三版(精简版):把"置 0"移到每轮开头,去除冗余分支,得到最干净的写法:
int compareVersion(string version1, string version2) {
int sum1 = 0, sum2 = 0;
int len1 = version1.size(), len2 = version2.size();
int index1 = 0, index2 = 0;
while (index1 < len1 || index2 < len2) {
sum1 = 0;
sum2 = 0;
while (index1 < len1 && version1[index1] != '.') {
sum1 = sum1 * 10 + version1[index1] - '0';
index1++;
}
while (index2 < len2 && version2[index2] != '.') {
sum2 = sum2 * 10 + version2[index2] - '0';
index2++;
}
index1++;
index2++;
if (sum1 > sum2) return 1;
if (sum1 < sum2) return -1;
}
return 0;
}
技巧提炼:版本号比较的通用套路是**"按分隔符切段、逐段比较、缺失段视为 0"**。循环条件 index1 < len1 || index2 < len2 配合"段内解析完成后 index++ 跳过 .",天然处理了两个版本段数不一致的情况。每轮比较完必须重置累加器,否则跨段累积会引入错误甚至溢出——这是本组题解复盘的核心教训。前导零问题无需特判,因为按十进制解析数字串天然会丢弃前导零。
5. 5461. 仅含 1 的子串数(连续 1 计数 + 取模)
给定仅由 0 和 1 组成的二进制字符串 s,返回所有字符都为 1 的子串数目,答案对 10^9 + 7 取模。1 <= s.length <= 10^5。示例:"0110111" → 9("1" 出现 5 次、"11" 出现 3 次、"111" 出现 1 次);"101" → 2;"111111" → 21;"000" → 0。
仓库笔记给出两版解法。第一版用前缀和思想预处理 dp[i] = dp[i-1] + i(即长度 i 的连续 1 串内部子串数为 i*(i+1)/2),再扫描连续 1 段求和:
int numSub(string s) {
int len = s.size();
int mod = 1e9 + 7,res = 0;
vector<int> dp(len + 1, 0);
for (int i = 1; i <= len; ++i) {
dp[i] += (dp[i-1] +i)%mod ;
}
for(int low = 0, high =0; low<len;){
if(s[low] == '1'){
high = low + 1;
while( high<len && s[high] == '1') { ++high; } //统计连续1的个数
res += dp[high-low];
res %= mod;
low = high -1;
}
low++;
}
return res;
}
第二版则更简单——边扫描边累加:每遇到一个连续的 1 就使 count++,并把 count 累加进结果(因为每多一个 1,以该位置结尾的连续 1 子串数恰为当前连续长度),遇到 0 则 count 归零:
int numSub(string s) {
int mod = 1e9+7,len = s.size();
int res = 0,count = 0;
for(int i = 0; i < len; ++i){
if(s[i] == '1'){
++count;
res = ( res + count )%mod;
}else{
count = 0;
}
}
return res;
}
技巧提炼:第二版的本质是动态规划的状态转移——res 在遍历过程中实时累加,无需额外数组。长度为 n 的连续 1 段内部共有 1 + 2 + ... + n = n(n+1)/2 个子串,两种写法殊途同归。对 10^9 + 7 取模是"答案可能很大"类题目的标准操作,务必在累加过程中取模而非最后一次性取模,防止中间结果溢出。
三、字符串题型共性技巧总结
综合以上 11 道题,可以把字符串题的核心方法论归纳为以下几点,这也是 InterviewGuide 该专题隐含的训练主线:
- 边界条件先行:字符串题 90% 的 bug 来自越界与空串。
i < len-1的防越界检查(13 题)、len == 0的判空(8 题)、全空格输入的处理(8 题),是必须形成肌肉记忆的检查项。 - 字符归一化:大写转小写(819 题)、忽略标点符号、去除前导零(165 题),本质都是"把输入规约到便于处理的形态"。
- 善用 STL:
unordered_map建映射(13 题)、stringstream分词(434 题)、find判子串(686 题)、reverse对齐低位(67 题),C++ 标准库足以覆盖绝大多数字符串基础操作。 - 双指针收缩:回文类(680 题)与版本号类(165 题)的标准范式都是双指针从两端/同步推进,关键在失配后的分叉处理(删左 or 删右)。
- 模拟走位与状态机:Z 字形变换(6 题)的方向翻转、atoi(8 题)的解析状态机,都需要"先判断状态再行动"的顺序。
- 溢出防护前置:任何
res * 10 + digit形态的累加,溢出判断都必须放在乘法之前(8 题、165 题)。
四、如何继续使用本专题
- 按目录顺序刷题:从 字符串专题目录 进入,Easy 全部吃透后再进入 Medium;
- 对照汇总版整体阅读:仓库在 total/02-字符串/easy/easy.md 与 total/02-字符串/medium/medium.md 提供了按难度合并的完整题解,适合整体通读与复盘;
- 回归算法模块总框架:字符串题常与其他标签交叉出题(如哈希表、双指针、回溯),刷完本专题后可回到 精选力扣300+题目总览 继续其他分类,保持知识体系的完整闭环。
最后,字符串题型的提升没有捷径——先把本文 11 道题的两到三种写法都独立实现一遍,再针对每一题的"易错点复盘"(如 819 题的分词边界、680 题的删除方向、165 题的累加器重置)做一次刻意练习,你就能在笔试面试中做到"遇串不慌、边界不漏"。
【免费下载链接】InterviewGuide
🔥🔥「InterviewGuide」是阿秀从校园->职场多年计算机自学过程的记录以及学弟学妹们计算机校招&秋招经验总结文章的汇总,包括但不限于C/C++ 、Golang、JavaScript、Vue、操作系统、数据结构、计算机网络、MySQL、Redis等学习总结,坚持学习,持续成长!
创作声明:本文部分内容由AI辅助生成(AIGC),仅供参考



