佚格麻瓜把力扣刷到中后期，很多人会陷入一个怪圈——题量涨了，手感却没涨。看着热题100刷了大几十道，遇到新题照样要从暴力开始试。真正拉开差距的不是题目数量，而是是否按“基础算法分类”建立自己的知识索引。位运算、数学、数组与字符串这四个大类，恰恰就是绝大多数热题背后的骨架，把骨架拆开，题目不再是一道道孤岛，而是一套可以迁移的解题模式。
这篇文章不是给你列题目编号清单，而是聊清楚位运算、数学、数组与字符串这四类题的核心原理怎么串起来。我会直接讲透最实用的模型、最难绕开的边界、以及我实际刷题和复盘过程中验证过的经验，包括递归法将整数n转换成字符串、最长公共前缀、2的幂判断、树状数组上二分这类看起来分散但底层逻辑一致的知识点。适合正在从头打基础的人，也适合刷到瓶颈想重新整理方法论的选手。
1. 为什么把位运算、数学、数组、字符串绑在一起刷
很多人的刷题顺序是从数组开始，刷到字符串觉得换了个世界，看到位运算直接跳过，等面试考到了才回来补。这样做的直接后果是：学过的知识点不能互相印证，背过的套路很快就忘。我后来重新整理思路，才发现这四个主题根本就是一条线上的四个节点。
1.1 按标签刷，比按难度刷更容易形成肌肉记忆
按难度刷看起来友好，今天做easy明天做medium，但easy和medium之间往往没有逻辑递进。你今天做的反转字符串，和明天做的两数之和，唯一的共同点是“都能做”，这对构建解题直觉没有任何帮助。按标签刷则不一样，连续几天都做位运算相关的题，你会自然总结出“异或能用来抵消重复项”“n & (n-1)能够删除最右侧的1位”这些规律。当规律从题目里长出来，就不需要死记硬背了。
我的做法是，一个分类至少集中刷20到30道题，不要贪快，每道题做完都把这四件事记下来：用了哪个模型、为什么这个模型能套用、最关键的边界是什么、能否换一道题继续复用。这样刷完一个分类，表格里会形成一张很清晰的映射关系。“看到什么条件→想到什么模型”，这个条件反射才是刷题真正的积累。
1.2 四个标签并不独立，它们互相渗透
数组题目里经常藏着位运算优化，字符串题目的核心可能只是双指针的数组遍历，数学题则需要先把问题抽象成数组模型。比如力扣里有一类题叫“只出现一次的数字”，表面是数组题，核心解法是异或位运算。再比如判断一个整数是不是2的幂，从数学上可以看对数的整数性，但工程上最漂亮的做法是 n > 0 && (n & (n - 1)) == 0。这就是为什么把这四类放在一起学习比零散刷效果好：你会不断看到同一个思维方式在不同场景里被调用。
我自己早期踩过一个大坑：用C++写字符串题时总忘记字符数组和字符串对象之间的差异，结果一道很简单的字符串排序题，被 strcmp 和 std::sort 的混合使用搞得焦头烂额。后来回到基础去理解C风格字符数组与 std::string 的关系，才明白字符串问题的很多坑不是逻辑问题，而是数据表示问题。这个认知是在同时刷数组和字符串时突然想通的。
1.3 这批知识覆盖了热题100中的一大半
点开力扣热题100，你会看到很多熟面孔：最长公共前缀、反转链表、最大子数组和、爬楼梯、只出现一次的数字……这些题拆到最底层，基本都落在位运算、数学、数组、字符串四个分类里。也就是说，把这几类基础算法打牢，你其实已经覆盖了刷题面试中最常被考察的高频区间。
所以我建议第一次系统刷题的人，第一轮不用急着上图论、动态规划这些重头戏，先把这四个分类吃透。这不仅是为了“好上手”，更因为它们是后续一切复杂模型的建筑材料。动态规划状态转移的本质是数组索引之间的推导，图论存图需要用数组和链表，位运算在状态压缩DP里几乎是唯一解法。地基不牢，后面每一层都会漏风。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 位运算：从“背结论”到“会推导”的五个底层模型
位运算这个分类，最让人头疼的地方是“每个符号都认识，组合在一起看不懂”。比如 n & (-n) 是怎么回事，x & (x - 1) 到底在什么场景用。其实位运算没有什么高深理论，就是二进制位上的逻辑操作，但你需要把它当成一种“按位思考”的直觉来训练。
2.1 先看透补码，后面所有题目才不会玄学
很多讲解一上来就列位运算性质，却很少讲为什么。位运算的前提是整数的二进制表示，而实际计算机中负数用的是补码。补码为什么要设计成“取反加一”？因为这样 x + (-x) 刚好在二进制加法器里自然溢出得到0，减法就不用额外设计了。不理解这一层，常见的 lowbit 计算——也就是 n & (-n)——就会变成需要背的魔法。
当n为正整数时，-n 等于按位取反再加1。取反操作把原来最低位的1变成了0，把它右边的0全变成了1；再加1后，进位又会把这些1重新归零，只有原来最低位那个1所在的位置被保留为1。所以 n & (-n) 得到的结果，是n的二进制表示中最低位的1以及它右边所有0组成的一个数。比如n=12，二进制是1100，n & (-n) 就是4（0100）。这就是树状数组的核心操作。补码懂了，lowbit就不用背了，你自己能推出来。
2.2 异或的小剧场：同一个数异或两次等于没异或
异或运算最常见的性质是：x ^ x = 0，x ^ 0 = x，并且满足交换律和结合律。这两条合在一起，会诞生一个特别经典的数组题：给定一个数组，只有一个数字出现一次，其余都出现两次，找出这个数字。
你的第一反应可能是用哈希表统计。但如果允许用位运算，一行代码就解决：把所有数字异或起来，成对出现的数字会自己抵消成0，剩下的结果就是落单的那一个。我第一次看到这个解法时觉得是奇技淫巧，后来才意识到这就是异或的数学本质：在二进制层面做无进位加法。两个一样的数对应位都相同，加完就是0。这个模型的迁移范围很广，比如找缺失数字、比较两个整数是否不同，甚至可以用异或实现无临时变量交换两个数。注意，无临时变量交换在实际工程代码里并不推荐，因为可读性差，但在算法思路扩展上却是一个很好的思维体操。
2.3 n & (n-1)：专门删除二进制最右边的那个1
这个模型适合用来数一个整数二进制中有多少个1，也适合判断2的幂。原理特别直接：当你对一个数减1时，二进制从最右侧的1开始，右边的低位全变1，那一位本身变成0，高位部分不受影响。例如10的二进制是1010，减1后是1001。对比一下会发现，原来最右边那个1，也就是倒数第二位，被变成了0。因此 n & (n-1) 的结果就是把原数最右边的1消掉了。
利用这一点，循环执行 n = n & (n - 1) 并计数，循环次数就是二进制中1的个数。这个技巧在力扣剑指offer的“二进制中1的个数”等题目中就是最优解之一。判断2的幂也是同理：如果一个正整数是2的幂，它的二进制形式只有一个1，那么执行一次 n & (n-1) 后结果应该变成0。注意不要漏掉 n > 0 这个前提，因为0和负数在这个判断下会有歧义，这也是面试官经常挖的边界陷阱，特别容易出现低级但致命的严谨性错误。
2.4 lowbit和树状数组上二分：位运算不只是简单题专属
很多人以为位运算只出现在简单题里，真正需要硬核功底的是树状数组。树状数组维护的是前缀和，单点修改和前缀查询都是O(log n)。但在某些场景下，你要根据前缀和反向定位位置，比如“在所有元素之和至少为k的最小前缀位置”。
朴素做法是二分位置mid，用树状数组查询前缀和，判断是否达到k。这样每次查询O(log n)，二分又要O(log n)，总复杂度O(log^2 n)。而利用lowbit，可以在树状数组上直接做“二进制倍增”式的二分，总复杂度降到O(log n)。核心思路是：从高到低枚举二进制位，尝试让当前索引加上某个2的幂次，累加这个区间的和，如果累加后仍小于k，就真正累加并移动索引。这段逻辑有点绕，但亲手写一遍之后，你对lowbit的理解会超越很多只会背模板的人。当年我终于在力扣热题讨论区看到有人用这个方法优化一道“按权重随机选择”的题时，才理解不是题目偏门，是我自己把位运算学浅了。
2.5 位掩码不是数据结构，是一种压缩手段
位运算还有一个被低估的应用：状态压缩。当状态只有“选/不选”两种，且数量不超过20个左右时，可以用整数的二进制位来代表集合。比如数组里的每个数取还是不取，可以把选中的下标对应位置设为1，那么枚举所有可能的子集就是从0遍历到 (1 << n) - 1。
这种做法的优势是省空间、便于用位运算符快速判断集合关系。但要提醒你，候选人做状态压缩题时最常见的错误不是位运算不对，而是数组下标和位编号搞混。如果你用第i位代表第i个元素，移位方向必须和位序逻辑保持一致。我自己就因为在 1 << i 和 1 << (i + 1) 之间反复横跳，调试了一个下午。建议先在纸上写几个小例子，验证编译逻辑后再套到状态转移方程里，这能帮你节省大量定位时间。
3. 数学题：递归、幂次、进制转换和建模思路
数学类题目在LeetCode里数量不少，却常常被归类为“脑筋急转弯”。其实这类题极其适合用来训练建模能力和边界控制能力。它们表面上千变万化，内里却有几种高频的思维模型。
3.1 “递归法将一个整数n转换成字符串”：一道题打通递归和进制两条脉络
有一个很老的经典题目是：输入一个整数n，用递归法将它转换成字符串输出，要求不要用格式化输出的库函数。比如输入12345，输出"12345"。这道题的常见解法非常简洁：递归调用处理n去掉最后一位后的部分，然后输出当前位的字符。
cpp复制void intToStr(int n) {
if (n < 0) {
putchar('-');
n = -n;
}
if (n >= 10) {
intToStr(n / 10);
}
putchar('0' + n % 10);
}
逻辑是先递归到最高位，等回溯时再逐位输出。但初学者常犯的错误是直接正序输出n%10，这样输出是反的。改用递归后，程序自动利用调用栈完成了逆序。这种“把逆序问题交给递归结构去处理”的思想，和反转链表、二叉树后序遍历都是同一套底层逻辑。
另一件值得注意的事是，这段代码里有一个“先处理符号，再取绝对值”的流程。看起来天经地义，但如果你要处理的不是int而是Integer.MIN_VALUE，情况就会变得麻烦：因为绝对值会溢出。所以更稳妥的做法是用 long 或者把负数单独处理，而不是直接取绝对值。这个细节也是数学题里最典型的“边界比逻辑更容易害死人”的案例。
3.2 判断2的幂、3的幂、4的幂：一道通式解一类题
列一下LeetCode常见系列的判断条件，你会看出非常清晰的方法论层次。判断一个数是否是2的幂，可以用 n > 0 && (n & (n - 1)) == 0。判断是否是4的幂，可以在2的幂基础上加一个约束：4的幂的二进制中，唯一的1出现在偶数位上。因此可以再与 0x55555555 做与操作，如果不为0就是4的幂。判断是否是3的幂，由于3没有二进制上的简单模式，最简单的办法是找到int范围内3的最大幂次，比如1162261467，然后看它是否能被n整除。
cpp复制// 4的幂
bool isPowerOfFour(int n) {
return n > 0 && (n & (n - 1)) == 0 && (n & 0x55555555) != 0;
}
这类题目真正的价值不是让你背公式，而是让你体会“数学性质如何被翻译成位模式”。如果直接从数学角度用对数判断2的幂，很容易遇到浮点数精度误差；但从二进制模式判断，就是纯整数运算。所以在做这类题时，我会刻意要求自己给出至少两种解法，一种偏数学、一种偏位运算，再比较它们的边界差异。这个过程比单纯ac一道题有用得多。
3.3 反转数字：溢出是考题故意埋的“地雷”
LeetCode第7题“整数反转”是这样的：给你一个32位有符号整数x，返回将数字部分反转后的结果，如果反转后超出范围，返回0。很多人的初版实现只考虑正数，直接循环 res = res * 10 + x % 10，但忽略了负号，也忽略了溢出。
处理负号可以先保存符号，对绝对值做反转，最后还原。但和前面的字符串转换一样，Integer.MIN_VALUE的绝对值会导致溢出。更常见的做法是边构造边判断：如果res可能会在再一次乘以10并加数后溢出，就直接返回0。
java复制public int reverse(int x) {
int res = 0;
while (x != 0) {
int digit = x % 10;
if (res > Integer.MAX_VALUE / 10 || (res == Integer.MAX_VALUE / 10 && digit > 7)) {
return 0;
}
if (res < Integer.MIN_VALUE / 10 || (res == Integer.MIN_VALUE / 10 && digit < -8)) {
return 0;
}
res = res * 10 + digit;
x /= 10;
}
return res;
}
这个做法的好处是把溢出判断揉进了循环内，不需要预先知道最终位数。实际面试时，我建议你先把基本循环写出来，再主动和面试官聊溢出问题，这样比一上来就甩出完整边界判断更显得有思考过程。
3.4 模运算、因数、gcd：哪些数学题值得优先看
除了递归转换、幂次判断，数学分类里还会反复出现模运算、最大公约数、素数判定、组合数取模这些知识点。比如“圆环上行走后回到原点”“在由因数和倍数构成的数组里找最大整除子集”这类题，核心其实是排序加动态规划。第一次做容易懵，一旦看穿了，你会发现它们考的还是数组、状态和数学性质的交叉。
我建议优先掌握欧几里得算法求gcd，以及快速幂取模两者。因为它们是后续数论题和很多动态规划优化题的基础工具。快速幂的核心思想是将指数按二进制拆解，时间复杂度从O(n)降到O(log n)，这本身也和位运算挂上了钩。你会在这种交叉点反复体会到，为什么我说这四类标签应该一起刷。
4. 数组题：双指针、二维遍历与树状数组上二分的实战
数组是力扣题量最大、出现频率最高的数据类型。很多人觉得数组简单，无非是遍历、排序、哈希表，可一旦题目上升到二维数组指针、双指针维护区间、树状数组上二分，就开始露怯。
4.1 双指针不只是“一左一右”，而是“维护不变量”
双指针最常见的三种模式是：快慢指针用于链表成环检测、左右指针用于有序数组的二分查找或两数之和、滑动窗口用于连续子串/子数组问题。它们的共同点是“每次移动至少一个指针，避免无意义的重复枚举”。
以两数之和为例，数组已排序时可以用左右指针：如果当前和小于target，左指针右移，整体和才会变大；如果当前和大于target，右指针左移，整体和变小。关键是每一步都基于已排序的单调性做放弃，而不是盲目尝试。这个过程非常像二分查找里的区间收缩，思维模型一脉相承。
滑动窗口本质上也是一种双指针，只不过需要维护窗口内和/字符频次等状态。我曾为了直接用 unordered_map 统计窗口字符而写了复杂代码，后来发现固定长度窗口用数组频次或者快速去重会更简单。做数组题时，多问自己一句“是否信息和下标都具备单调性”，比递归调用模板更能找到简洁解。
4.2 树状数组上二分：数组前缀信息的动态查询
前面的位运算部分提过lowbit，现在说清楚树状数组上二分的应用场景。标准的树状数组支持单点更新和前缀和查询。但当数据是动态变化时，比如频繁修改和频繁根据累计值查找下标，使用朴素的“二分+前缀和查询”会是O(log^2 n)。如果系统对延迟有要求，就需要直接“在树状数组这一棵结构上二分”。
模板可以抽出来理解。假设目标是寻找最小的下标pos，使得 sum(pos) >= target。你从当前枚举的幂次 step = highbit(n) 开始往下减半，检查 pos + step 位置的管理区间总和：
cpp复制int findByOrder(vector<int>& bit, int target) {
int pos = 0;
int n = bit.size() - 1;
// 从最高位到最低位枚举
for (int step = 1; step <= n; step <<= 1);
for (; step; step >>= 1) {
int next = pos + step;
if (next <= n && bit[next] < target) {
pos = next;
target -= bit[next];
}
}
return pos + 1;
}
这段代码的精髓在于：沿lowbit构成的二叉路径逼近目标，而不是真的做二分查找。每次跳到的位置本质上对应一个树状数组节点，查这个节点维护的区间和，比逐点快。能用到的场景包括“在动态集合中按权值查询第k小”“非严格前缀和的定位”。如果你只是追求ac，可以把它归为高级模板；但我建议至少亲手推演几遍，因为它是位运算优雅性的最好演示。
4.3 C/C++ 二维数组和多维指针：别让语法毁掉算法思路
算法本身不难时，很多人会死在C++二维数组传参上。力扣刷题经常遇到函数签名给的是 vector<vector<int>>&，但你自己写练习代码想用原生二维数组，就会牵扯到“数组名退化”的概念。
二维数组 int arr[3][4] 的类型是 int (*)[4]，而不是 int**。很多人把二维数组传给 int** 参数后编译器报错，一脸茫然。原因是 arr[0] 是一个一维数组，当它被当作指针使用时是 int*，指向第一行的第一个元素；但 arr 的退化只发生在第一维，第二维的长度是类型的一部分。所以如果你需要动态二维结构，C++更自然的做法是用vector嵌套vector，或者自己用一个一维vector模拟二维矩阵，通过 row * cols + col 访问元素。
这种方法在实际开发里也很有用，能减少内存碎片，也能缓存友好地遍历大矩阵。力扣上很多二维动态规划题完全可以拍平成一维索引来做。我看到不少人因为写出 vector<vector<int>> dp 之后，又要在行与列之间横跳，其实先拍平一维，反而能让状态转移写得更隐蔽但更清晰。这算是自选熟练语言后才有的小技巧。
4.4 去重、归并、原地操作：数组题的隐藏套路
数组去重听起来是哈希表的天下，但如果要求原地去重并返回新长度，经典的解法是“双指针覆盖”：一个指针遍历，另一个指针指向当前已去重部分的末尾。只要遇到和前一个不同的数，就把它搬到“末尾指针”的位置，然后末尾指针后移，最后末尾指针就是新长度。
归并排序里归并两个有序数组也是类似思路，不过为了原地节省空间，往往需要从后往前填充。这个“从后往前”的动机很常见：如果从前往后覆盖，会破坏还没处理的元素；从后往前则预留了足够的空间，让覆盖顺序安全。类似的技巧在做“合并两个有序数组”题目时特别有用，往往一次遍历就能解决，不需要额外数组。建议把这类题总结为“维护写指针和读指针”的模板，后续做字符串原地压缩题时还能继续套。
5. 字符串：排序、公共前缀、数字互换的细节清单
字符串题可能是四类中“工程味”最重的一类。逻辑往往不难，坑却密布在字符集、大小写、空串、符号等细节上。工程环境下后台处理字符串时，会遇到类似于SQLServer里字符串转数字、触摸屏底层字符串显示异常之类的问题；算法题里的字符串处理，则是让你先在干净环境里养成防御性习惯，等去了工程现场不会裸奔。
5.1 C++字符串数组初始化：先从基础语法解除恐慌
很多C++新手在定义字符串数组时会很迷惑：到底该写 string strs[10]，char* strs[10]，还是 char strs[10][20]。如果是定长字符串数组，char strs[10][20] 表示有10个字符串，每个最长19个字符再加结束符。如果是动态字符串数组，推荐直接用 vector<string>，既方便排序又方便修改。
初始化时要注意 char* 指针数组并不会自动分配存储空间，如果直接把一个字符串字面量赋给它，字面量在C++里是 const char[]，存在只读区。不要试图修改它。而 char arr[][N] = {"abc", "def"} 这种初始化则会在栈上复制字符串，可以安全修改。用 std::string 时就不用担心这些问题，std::sort(strs.begin(), strs.end()) 可以直接按字典序排序。
有一次我封装一个接口时用了 char* 数组，结果因为共享了同一块缓存导致全部字符串都变成了最后写入的内容。排查后才发现问题出在我没有逐字符串分配内存。经历这些之后，我在做题时如果语言没有特殊要求，尽量选择带自动内存管理的类型，而把C风格字符串留给确实需要贴近系统底层的题目。
5.2 最长公共前缀：一题串起三种字符串遍历思维
力扣第14题“最长公共前缀”是入门必刷题，但你认真对待它，能学到的远不止“逐个字符比一比”。标准解法是先取第一个字符串作为前缀，然后逐个和后面的字符串比较，不断缩短前缀。也可以纵向比较：我们同时扫描所有字符串的第i位，如果全部相同就继续，否则停止。
纵向比较的边界需要特别注意：当i已经超过了某个字符串的长度，说明该字符串已经到头了，公共前缀不可能再变长，直接返回当前结果。很多人在这个问题上忘记判断“当前字符串是否够长”，导致越界访问。解决方式也很简单：先检查i是否等于当前字符串的长度，如果是就直接返回 strs[0].substr(0, i)。
如果你进一步思考，这题还可以用分治或二分。比如先求前一半字符串的公共前缀，再求后一半的公共前缀，最后合并两个结果。这种做法的额外价值在于让你重新审视字符串的“可分段拼接性”，对后续处理“最长回文子串”之类的题有帮助。
5.3 字符串转数字：自己实现和库函数的差距
算法题经常要求你手写字符串转整数的功能。力扣第8题“字符串转换整数(atoi)”把这个需求考到极致：要处理前导空格、正负号、数字前后可能出现的乱字符、整数溢出，以及空字符串。很多人觉得这道题很烦，但仔细想想，这不就是工程里每个日期解析和参数解析都要面对的情况吗？
正统做法是维护一个当前结果res，每读到一个数字字符就执行 res = res * 10 + (c - '0')，并且在累加前判断是否超过int范围。很多人忘记 c - '0' 的本质，是因为字符'0'到'9'的ASCII码连续，减去'0'的码值正好得到数字本身。这里还牵出一个常见工程问题：字符串转数字在某些数据库或脚本语言里会有不同行为，比如SQLServer的转换对非法字符报错，而在其他语言里可能会截断。底子好的开发者会发现，自己实现一个转换器时完全能预料到这些差异，这就是算法题扎实的隐性回报。
5.4 大小写转换、逆序和去重：细节都在字符集上
字符串大小写转换看似无脑：遍历字符串，对每个字母调用 tolower 或 toupper。但如果要写一个“忽略大小写的回文判断”，就需要额外思考字符的范围。英文字母大小写转换的ASCII码差是32，因为'A'是65，'a'是97，所以 'a' - 'A' == 32。这个规律在位运算里甚至可以直接用 c | 32 来把大写转小写，也可以用 c & ~32 把大写转大写，当然这种技巧可读性不高，面试时更适合作为补充思路而非主解。
字符串逆序的常见做法是双指针交换，如果题目要求“按单词反转”，还得先整体反转再局部反转。这类题的共同点是注意空格和单词边界，尤其是连续多个空格的情况。字符串去重在算法题中则经常以“删除相邻重复项”出现，可以用栈来模拟，也可以原地双指针。
5.5 Java、C#、Delphi等语言里的字符串差异
语言差异是字符串题最大的隐性杀手。Java的字符串是不可变的，每次拼接都会产生新对象，循环内大量使用 + 拼接会带来很大的性能开销，刷题时更推荐用 StringBuilder。C#的字符串同样不可变，也有类似StringBuilder类型的可变字符串类，而且C#的string可以直接用索引访问字符，这点和Java一样。C++的 std::string 是可变的，对单字符修改很方便，但也因此容易在并发环境下踩坑。Delphi的字符串类型在不同版本之间语义变化很大，作为字典的key时要特别注意拷贝和哈希规则。
我做过一次Java和C++的对比实验：处理500万次字符串拼接时，C++用 += 操作 std::string 效率远高于Java的 +=，但Java改用 StringBuilder 后差距缩短很多。这些细节不影响你写对算法，但影响你写出能扛住线上压力的代码。算法题的价值就在于，让你在讨论算法之外，还能有底气谈论这些工程层面的取舍。
6. 刷题落地建议：分类做题后的复盘与反哺
掌握了前面的知识点，最怕的就是“看懂了但没写出来”。我觉得有必要分享一套落地的刷题节奏，以及我自己复盘时真正会记录的内容。
6.1 一个可以直接照抄的第一轮刷题顺序
第一轮最好限制在4周内，按顺序走位运算→数学→数组→字符串四块。每块花一周，每天做3到5道中等难度左右的题。不必贪多，重要的是每天保持触感。位运算先做基础题，比如只出现一次的数字、位1的个数、2的幂；数学做整数反转、回文数、罗马数字转换；数组集中做双指针和滑动窗口；字符串做最长公共前缀、反转字符串、字符串转换整数。
每周末把本周做过的题重新看一遍，这次不看答案，而是直接在空白处写下解法框架和复杂度。如果写不出来，说明还没经过记忆沉淀，需要标记后加练同类题。一个分类通过“学→练→回看”三遍反复，比广泛刷一遍牢固得多。
6.2 不要只看不写，输出才是检验标准
我在社区里见过很多只看题解夸夸其谈的人，也在实际面试中见过这类人，一旦被要求手写代码，细节漏洞就全暴露。输出方式有三种层次：第一层是默写核心代码，保证语法正确；第二层是讲解给别人听，能回答“为什么这里要取等号”“为什么必须从后向前遍历”；第三层是尝试修改题目条件，提出新的解法或优化方向。
第三层听起来像额外负担，但极有用。最长公共前缀能不能用二分做？反转整数如果允许用long是否能简化边界判断？只出现一次的数字如果题目变成“有两个数只出现一次”又该怎么处理？这些问题是一个能把你从“会做题”推进到“会出题”的最佳路径。
6.3 复盘模板：少记过程，多记“判断依据”
复盘不是把代码贴进笔记就结束了，那样等于没有复盘。我会用一个很简单的表格记录每个分类下面重复出现的模式。例如位运算分类下，记录“异或可用于抵消相同项”“n & (n-1) 可用于消除最右1位”“lowbit可用于树状数组和权值查找”；数组分类下，记录“双指针的使用前提是单调性”“原地去重的思路是维护写指针”等。关键在于每一条都要配一道代表题，以及一个“如果下次看到什么条件，可以优先想到它”的判断信号。
这样一来，刷题笔记就不是题解大全，而是一本“条件反射手册”。到后期做新题时，我会先对题目信息做模式匹配，而后针对匹配到的模型填入边界细节。面对陌生题目，至少能快速分析出它更贴近哪一类底层算法，从哪个角落开始拆解，这比背模板有效得多。
把位运算、数学、数组、字符串当作一个整体去啃，最大的好处是你会发现知识之间互相呼应：数组题的异或解法和位运算的“奇偶抵消”一致，数学题的进制转换和递归结构一致，字符串题的索引边界和数组双指针的区间维护一致。这种底层相通的感觉，是继续挑战图论和动态规划之前最好的铺垫。我自己也在带新手时反复强调，不要急着追求刷题数量，先花几周把这一段打透，后面无论学状态压缩还是线段树，都会顺手很多。