排序、二分、前缀和、差分、双指针：算法笔试必备基础复习

面试前夜，我把排序、二分、前缀和、差分、双指针这五块基础算法从头到尾重新推了一遍，才发现很多自以为懂的东西其实只是“背住了代码”，真要讲清楚原理、处理边界、应对变形题，还是有漏洞。这篇复习笔记不是教科书式的罗列，而是按照笔试面试的实际命题习惯，把这五个高频考点串起来讲，每个都附上可以直接用的模板代码和我在刷题实战里踩过的坑。

如果你是正在准备算法笔试的在校生，或者工作中需要偶尔手撕数据结构的开发者，这篇内容应该能帮你用最短时间把基础算法重新立起来。核心关键词就是这五个：排序、二分、前缀和、差分、双指针，它们之间其实有很强的互补关系，很多人只把它们当独立知识点背，忽略了组合用法，这恰恰是面试官最爱挖的地方。

1. 为什么这五个算法是笔试面试的“必考常客”

先说个观察。你翻任何一家公司的笔试题库，或者任何一所高校的算法期末考试卷，排除掉动态规划和图论这种大块头，出现频率最高的其实就是这五个基础工具。它们不是单独的考点，而是整个算法体系的“基础设施”。就像盖房子用的砖块和水泥，没人会单独夸一块砖好，但没有砖，什么都建不起来。

从命题人的角度看，这五个算法有几个共同特点：实现难度适中、考察点明确、容易出变形题、代码量不大但细节极多。一个二分的边界条件就能筛掉一大半人，一个前缀和的初始化问题也能让不少人在笔试里翻车。它们很适合用来快速区分“背过模板”和“真正理解”的候选人。

更重要的是，这五个算法之间是可以互相嵌套的。面试里最常见的出题套路是：先给一个数组，要求排序（排序），然后在这个有序数组上做查找（二分），接着问某个区间的和（前缀和），再升级成“如果对区间做多次修改怎么办”（差分），最后要求用O(n)时间解决“找满足条件的最短子数组”这类问题（双指针）。你看，一整道题下来，五个考点全考了。这就是为什么我建议复习的时候不要把每个算法焊死在自己的单元里，而是把它们当作一个工具箱里的不同工具，理解它们各自适合什么场景，怎么配合使用。

还有一个很现实的原因：不管是校招笔试、考研机试，还是 ACM 的入门题，这些算法的裸题都是“送分题”。如果你连送分题都拿不稳，后面的难题基本没戏。反过来，如果这几个基础工具足够扎实，即使遇到没见过的难题，你也至少能写出一个次优解拿部分分数，笔试的通过率会完全不一样。

总结一下这部分的关键认知：

• 排序、二分、前缀和、差分、双指针是算法题的“基础设施”，不是孤立知识点。
• 它们经常嵌套出现在同一道题里，所以复习时要重视组合用法。
• 对笔试来说，这些题的性价比最高，务必修到“闭着眼都能写对边界”的程度。

2. 排序：别只调sort()，手撕也要拿得出手

很多准备面试的同学会有一个误区：排序不是有现成的 sort() 函数吗？为什么还要手写？我在面过别人的时候也经常问这个问题，得到的回答大多是“用库函数就行了”。但笔试和面试考排序，从来不是考你调库函数，而是考三件事：你懂不懂排序背后的分治思想、能不能在特定约束下选对排序算法、能不能手写出来并分析复杂度。

2.1 快排的 partition 思想是很多题的源头

快排的核心不是“递归”，而是 partition（划分）。它做的事情是：选一个基准值，把数组分成左小右大两半，然后递归处理两边。这个思想单独拎出来，能解决一大批问题，比如“找数组中第K大的元素”“求数组最小的K个数”，本质上都是 partition 的变体。

我直接给出一个最不容易写错的快排模板，这个实现采用“挖坑法”，比交换法的边界更容易理解：

cpp复制void quickSort(vector<int>& arr, int left, int right) {
    if (left >= right) return;
    int pivot = arr[left + (right - left) / 2]; // 选中间位置防止最坏情况
    int i = left, j = right;
    while (i <= j) {
        while (arr[i] < pivot) i++;
        while (arr[j] > pivot) j--;
        if (i <= j) {
            swap(arr[i], arr[j]);
            i++;
            j--;
        }
    }
    quickSort(arr, left, j);
    quickSort(arr, i, right);
}

几点经验说明：

• 基准值不要每次都选 left，否则对于已经有序的数组会退化成 O(n²)。选中间位置或随机位置的退化概率要低得多。
• 退出循环后的递归边界是 [left, j] 和 [i, right]，不是 [left, i-1] 这类容易搞错的范围。建议直接背这个写法，不容易乱。
• while (arr[i] < pivot) 这里必须是严格小于，不能是 <=，否则遇到重复元素会死循环。

快排在工程里的实际地位也是最高的，因为它的常数小、原地排序、缓存友好。C++ STL 的 sort 就是快排的优化版，元素少时切换到插入排序，递归深度过深时切换到堆排序，这个混合策略在工程上非常经典。

2.2 归并排序的“合并”思想是逆序对和外部排序的基础

归并排序的代码比快排更规整，它严格遵循分治三步：拆成两半、分别排序、合并。合并过程需要额外的 O(n) 空间，这是它的主要缺点，但它的优势是稳定，并且在合并时可以做很多“附加计算”。

最典型的附加计算就是求逆序对数量。在合并两个有序子数组时，如果左半部分的某个数大于右半部分的某个数，那么左半部分从这个数开始到结尾的所有数，都和当前右半部分的数构成逆序对。这个逻辑在归并模板里只差两行代码：

cpp复制long long mergeCount(vector<int>& arr, vector<int>& tmp, int left, int mid, int right) {
    int i = left, j = mid + 1, k = left;
    long long cnt = 0;
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            tmp[k++] = arr[i++];
        } else {
            tmp[k++] = arr[j++];
            cnt += mid - i + 1; // 左半部分剩余元素都大于 arr[j]
        }
    }
    while (i <= mid) tmp[k++] = arr[i++];
    while (j <= right) tmp[k++] = arr[j++];
    for (int p = left; p <= right; p++) arr[p] = tmp[p];
    return cnt;
}

归并排序还有一个应用就是外部排序。当数据量大到无法全部载入内存时，只能一部分一部分读入，排序后写到临时文件，最后做多路归并。这个场景下归并排序几乎是唯一选择，这也是为什么它在工程中的地位不可替代。

2.3 插入排序与“近乎有序”的数组

有一种情况插入排序比快排还快：数组已经“几乎有序”时。插入排序的复杂度是 O(n²)，但针对完全有序的数组，它的实际比较次数是 O(n)。C++ STL 的 sort 在小区间内切换到插入排序，就是利用了这个特性。

插入排序的实现也有技巧，标准写法是：

cpp复制void insertionSort(vector<int>& arr) {
    for (int i = 1; i < arr.size(); i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

如果你需要稳定性，又不想写太多代码，插入排序是个不错的选择。它不需要额外空间，稳定，对小规模数组非常友好。

2.4 排序算法的选型经验表

面试时很容易被问“这个场景用什么排序”，这里总结一个实用对照表：

排序章节的最后一定要提一个高频变形：字符串排序。很多笔试会考察多关键字排序，比如先按长度排，再按字典序排。这类题的核心不是排序本身，而是比较函数怎么写。C++里可以自定义比较：

cpp复制sort(strs.begin(), strs.end(), [](const string& a, const string& b) {
    if (a.size() != b.size()) return a.size() < b.size();
    return a < b;
});

在 Java 里对应的是 Comparator，Python 里是 sorted(strs, key=lambda x: (len(x), x))。记住一个原则：多关键字排序永远用元组或组合 key，不要写复杂的 if-else 比较。

3. 二分与前缀和：一对联手解决区间问题的最佳搭档

线段树和树状数组解决的是动态区间问题，但如果数据是静态的，前缀和就是最简单好用的工具。二分则解决的是一种更基础的搜索问题——在一个满足单调性的序列里快速定位目标。两者单拎出来都很简单，但组合在一起，能解决大量看起来毫无头绪的问题。

3.1 二分的本质是“单调性”，不是“有序数组”

这是二分最容易踩的认知误区。很多人一看到二分就想到“有序数组”，其实二分的真正适用条件是“存在一个分界点，使得分界点两侧的性质不同”。这个性质可以是数值大小关系、判断函数 true/false 的变化，甚至可以是数组下标与索引值的对应关系。

举个例子，寻找峰值元素这道题，数组并不是全局有序的，但只要满足相邻元素不相等，就可以二分：如果 nums[mid] < nums[mid+1]，说明峰值一定在右侧；否则峰值一定在左侧（包含 mid）。这个结论的本质就是利用了“单调性”——不是数值单调，是“趋势”在某一段区间内是可判定的。

还有一个更极端的例子是 x 的平方根，要求在整数范围内求 sqrt(x) 的整数部分。它可以建模为：找到最大的 mid，使得 mid * mid <= x。判断条件就是“平方是否小于等于目标”，这个条件在整个整数范围内是单调的：小的 mid 一定满足，大的 mid 一定不满足。所以可以二分。

二分模板我建议分成两类记忆：

第一类：求“第一个满足条件的元素位置”

cpp复制int lowerBound(vector<int>& arr, int target) {
    int left = 0, right = arr.size(); // 左闭右开
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] >= target) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

第二类：求“最后一个满足条件的元素位置”

cpp复制int upperBound(vector<int>& arr, int target) {
    int left = 0, right = arr.size();
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] <= target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left - 1;
}

这两个模板使用“左闭右开”区间，循环条件是 left < right，不需要考虑 left == right 的情况，能避免一大半边界问题。注意 mid 的取法：第一类是向下取整，第二类实际上也是向下取整（left + (right-left)/2），这里都是在左闭右开区间下实现的，逻辑是一致的。

对于找“最后一个满足条件的”还有一种写法，用向上取整的 mid 配合闭区间。但我不建议同时记两套模板，容易混。你只要记住上面这一套“左闭右开 + 一个判断方向”的组合，再在草稿纸上模拟几次，基本就不会错了。

3.2 前缀和的原理与一维二维写法

前缀和解决的问题是：静态数组上频繁查询任意区间 [l, r] 的和。如果每次查询都遍历一遍，单次查询是 O(n)，m 次查询就是 O(n*m)。前缀和的思路是预处理一个数组 pre[i] 表示原数组前 i 个元素的和，这样区间和就是 pre[r+1] - pre[l]，单次查询变成 O(1)。

一维前缀和的初始化要注意一个细节：pre 数组的长度是 n+1，第 0 位存 0，这样处理 l=0 的时候不需要特判：

cpp复制vector<int> prefixSum(vector<int>& arr) {
    int n = arr.size();
    vector<int> pre(n + 1, 0);
    for (int i = 0; i < n; i++) {
        pre[i + 1] = pre[i] + arr[i];
    }
    return pre;
}
// 查询 [l, r] 的和：pre[r + 1] - pre[l]

很多人写错前缀和的场景是“下标对不上”。核心记忆方法：pre[i] 表示“前 i 个元素的和”，所以 pre[0] = 0，pre[1] = arr[0]，以此类推。查询 [l, r]，注意这里 r 是包含的右端点，结果是 pre[r+1] - pre[l]。

二维前缀和稍微复杂一点，但原理完全一样。pre[i][j] 表示从 (0,0) 到 (i-1,j-1) 这个矩形区域的和。初始化时用容斥原理：

cpp复制vector<vector<int>> pre(m + 1, vector<int>(n + 1, 0));
for (int i = 1; i <= m; i++) {
    for (int j = 1; j <= n; j++) {
        pre[i][j] = pre[i-1][j] + pre[i][j-1] - pre[i-1][j-1] + arr[i-1][j-1];
    }
}

查询以 (x1,y1) 为左上角、(x2,y2) 为右下角的矩形和：

cpp复制int sum = pre[x2+1][y2+1] - pre[x1][y2+1] - pre[x2+1][y1] + pre[x1][y1];

二维前缀和的难点主要就是容斥公式，建议在纸上画一个 2x2 的格子推一遍，印象会非常深。面试官如果考二维前缀和，一般是配合矩阵旋转或子矩阵计数这类变形题。

3.3 二分与前缀和的组合拳：最大化最小值问题

前缀和与二分最常见的组合是“二分答案”题型。这种题的特征是：要求你找一个“最大值的最小值”或“最小值的最大值”，并且直接暴力搜索会超时。经典例子是 在 D 天内送达包裹的能力 和 分割数组的最大值。

这类题的套路非常固定：

1. 确定答案的搜索范围（比如包裹能力的最小值和最大值）。
2. 写一个 check(mid) 函数，判断当前答案是否可行。
3. 根据 check 的单调性二分。

check 函数里往往需要线性扫描数组，扫描时可以配合前缀和快速计算区间和。举个例子，分割数组的最大值：给定一个数组，分成 m 段，求每段和最大值的最小值。check(mid) 判断“每段和都不超过 mid 的情况下，能否分成不超过 m 段”，这个判断本质上就是在数组上做划分为若干连续片段，每个片段的和不超过 mid，用贪心扫描即可，中途可以用前缀和来加速求当前片段结束位置的定位。

但说实话，大部分题里 check 直接用一个变量累加就够了，不一定真的需要前缀和。前缀和真正和二分配合更多的地方在于：在有序数组上先构建前缀和数组，然后二分查找某个前缀和的位置。例如“求数组中和不超过 K 的最长子数组”这类题，前缀和数组本身是单调递增的（原数组全为正数），就可以二分定位。

4. 差分与双指针：把复杂度降一个量级的两把刀

这两个算法的共同点是：它们都在“极致压榨遍历次数”。差分的思路是区间修改的延迟处理，双指针的思路是两个指针各走一遍。它们的核心都不是某个严格的模板，而是一种“如何减少无效计算”的思想。

4.1 差分的本质是区间修改的“记账本”

差分的应用场景很清晰：对一个数组的某个区间频繁执行“整体加一个值”的操作，最后再求数组最终的样子。如果每次修改都遍历区间，一次修改是 O(n)，m 次修改就是 O(n*m)。差分的优化思路是：不直接修改原数组，而是维护一个差分数组 diff，diff[i] = arr[i] - arr[i-1]（定义 arr[-1] = 0）。

对区间 [l, r] 整体加 val，只需要两步：

cpp复制diff[l] += val;
diff[r + 1] -= val;

所有修改完成后，对 diff 数组做一次前缀和还原，就得到了最终数组：

cpp复制for (int i = 1; i < n; i++) {
    diff[i] += diff[i - 1]; // 现在 diff[i] 就是原数组第 i 个位置的值
}

这个思想可以通俗地理解为：diff 数组记录的是“每个位置相对于前一个位置的变化量”，区间修改只需要在起点标记“从这里开始要加”，在终点后一位标记“到这里结束”，最后从前到后扫一遍，把这些变化量累积起来，就能还原出每个位置的真实值。

差分的经典题目包括：航班预订统计、拼车、区间加法、1094. 拼车。尤其推荐 航班预订统计，它把差分的思想嵌套在了一个实际业务场景里，非常适合用来检验自己是不是真的理解了区间加和前缀和还原的过程。

二维差分也是同样的思路，处理的是“在一个矩阵的子矩形内统一加一个值”的批量操作。修改子矩形 (x1,y1) 到 (x2,y2)：

cpp复制diff[x1][y1] += val;
diff[x1][y2+1] -= val;
diff[x2+1][y1] -= val;
diff[x2+1][y2+1] += val;

然后对 diff 做二维前缀和还原。这个公式和二维前缀和的容斥公式是反着来的，强烈建议把两个公式一起记忆，因为它们是完全对称的关系。

4.2 双指针的核心是“单调性”，不是“两个循环”

双指针这个名字容易让人误解，以为就是“两个指针在数组上跑”。其实快慢指针、对撞指针、滑动窗口，都属于双指针的范畴。它们的共同前提是：随着一个指针的移动，另一个指针的移动方向是单调的，不会回头。这个“单调性”才是 O(n) 复杂度的来源。

最典型的例子是两数之和（有序数组版本）：给定一个升序数组和一个目标值，找两个数使它们的和等于 target。最直观的暴力法是两层循环 O(n²)。双指针解法是对撞指针：一个指向开头，一个指向结尾，根据当前和与 target 的大小关系决定移动哪个指针，因为数组有序，所以指针只会朝一个方向移动，整体 O(n)：

cpp复制vector<int> twoSum(vector<int>& numbers, int target) {
    int left = 0, right = numbers.size() - 1;
    while (left < right) {
        int sum = numbers[left] + numbers[right];
        if (sum == target) return {left + 1, right + 1}; // 返回下标从1开始
        else if (sum < target) left++;
        else right--;
    }
    return {};
}

为什么它一定是对的？因为数组有序，当 sum < target 时，右指针向左移动只会让和更小，所以唯一能增大和的方式是左指针向右移动。这就是“单调性”，少了这层证明，双指针就变成了一种碰运气的写法。

同向双指针的场景更多，最典型的就是滑动窗口。解决“最短子数组和>=K”这类问题时，右指针不断向右扩展窗口，当窗口满足条件时，左指针向右收缩窗口直到不满足条件，期间记录所有满足条件的窗口长度，取最小值。这个过程每个元素最多被左指针和右指针各访问一次，所以 O(n)。

4.3 双指针的高频变形模板

我整理了两个最常用的双指针场景，建议直接当作模板用：

场景一：无重复字符的最长子串（滑动窗口 + 哈希表）

cpp复制int lengthOfLongestSubstring(string s) {
    unordered_map<char, int> window;
    int left = 0, ans = 0;
    for (int right = 0; right < s.size(); right++) {
        char c = s[right];
        window[c]++;
        while (window[c] > 1) {
            window[s[left]]--;
            left++;
        }
        ans = max(ans, right - left + 1);
    }
    return ans;
}

这个模板的精髓是 left 的移动条件：当窗口内出现重复字符时，左指针不断右移并清理哈希表计数，直到窗口重新合法。

场景二：合并两个有序数组

这也是热词里提到的 java 双指针合并有序数组。双指针从两个数组的末尾开始比较，就能做到原地合并。核心逻辑：

cpp复制void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
    int i = m - 1, j = n - 1, k = m + n - 1;
    while (i >= 0 && j >= 0) {
        if (nums1[i] > nums2[j]) nums1[k--] = nums1[i--];
        else nums1[k--] = nums2[j--];
    }
    while (j >= 0) nums1[k--] = nums2[j--];
}

这个写法从后往前填充，避免了频繁移动元素的麻烦。很多人在笔试里写合并数组，第一个想到的是新建一个数组，但面试官往往期望你给出 O(1) 额外空间的解法，从后往前的双指针就是答案。

4.4 差分和双指针的边界场景对比

差分适合处理“多次区间修改后查询最终值”的场景，双指针适合处理“在线性遍历中维护某个窗口的统计特征”的场景。它们一个是从区间操作的角度降低复杂度，一个是从遍历次数的角度降低复杂度，经常在同一道题里出现。比如一道题先对数组做若干次区间修改（用差分），再求满足条件的最短子数组（用双指针），这种组合题在面试里很常见。

5. 真题实战与高频坑位排查

这部分选了四道有代表性的题目，覆盖五个算法，并列出我自己刷题时踩过的坑。这些题的难度适合基础复习，但坑点都是面试官最爱挖的细节。

5.1 排序+二分组合题：在排序数组中查找元素的第一个和最后一个位置

这是二分模板最经典的考法。先二分找第一个等于 target 的位置，再二分找最后一个等于 target 的位置。

第一次二分：找第一个>=target的位置。

cpp复制int left = 0, right = n;
while (left < right) {
    int mid = left + (right - left) / 2;
    if (nums[mid] >= target) right = mid;
    else left = mid + 1;
}
int first = left;

如果 first == n || nums[first] != target，说明不存在，直接返回 {-1, -1}。然后第二次二分找最后一个<=target的位置，复用上文的 upperBound 即可。

这里最容易犯的错是：第一次二分之后，忘记判断 first 是否越界，或者忘记判断 nums[first] 是否等于 target。很多人在有序数组里找不存在的元素时，返回了一个“看似合理”的错误下标，笔试判分就直接全错。

5.2 前缀和经典题：和为K的子数组

题目：给定一个数组，求有多少个连续子数组的和等于 K。暴力的做法是枚举所有子数组 O(n²)。前缀和的做法是：用哈希表记录已经出现过的前缀和及其出现次数，遍历数组时，对于当前前缀和 cur，查找 cur - K 出现过多少次，累加到答案中。

cpp复制int subarraySum(vector<int>& nums, int k) {
    unordered_map<int, int> mp;
    mp[0] = 1; // 前缀和为0出现过一次
    int cur = 0, ans = 0;
    for (int num : nums) {
        cur += num;
        if (mp.count(cur - k)) ans += mp[cur - k];
        mp[cur]++;
    }
    return ans;
}

这里的核心思想是“前缀和相减得到子数组和”。mp[0] = 1 的初始化经常被漏掉，漏掉之后，从数组开头到某个位置恰好等于 K 的子数组就会被漏数。这个细节我至少见三个人在笔试里翻过车。

5.3 差分经典题：航班预订统计

题目描述是：有 n 个航班，给定若干条预订记录 [first, last, seats]，表示从第 first 班到第 last 班每班增加了 seats 个座位，求最终每个航班的座位数。

用差分维护：

cpp复制vector<int> corpFlightBookings(vector<vector<int>>& bookings, int n) {
    vector<int> diff(n + 2, 0); // 多开一位，避免 r+1 越界
    for (auto& bk : bookings) {
        int l = bk[0], r = bk[1], seats = bk[2];
        diff[l] += seats;
        diff[r + 1] -= seats;
    }
    vector<int> res(n);
    int cur = 0;
    for (int i = 1; i <= n; i++) {
        cur += diff[i];
        res[i - 1] = cur;
    }
    return res;
}

这个题最常用的坑是：diff 数组的长度必须开到 n+2，因为 r+1 可能等于 n+1，如果只开 n+1 就会数组越界。还有一个细节是航班编号从 1 开始，而返回数组下标从 0 开始，下标换算容易出错。

5.4 双指针经典题：盛最多水的容器

题目：给定一个数组，每个元素代表一条垂直于 x 轴的线段高度，选出两条线段和 x 轴构成容器，求容器的最大容量。

对撞指针的解法是：

cpp复制int maxArea(vector<int>& height) {
    int left = 0, right = height.size() - 1;
    int ans = 0;
    while (left < right) {
        int area = min(height[left], height[right]) * (right - left);
        ans = max(ans, area);
        if (height[left] < height[right]) left++;
        else right--;
    }
    return ans;
}

正确性的直觉是：容器的容量受较短的那条边限制，无论移动较长的一边，容器宽度都会减小，容量必然不会超过当前值，所以保留较长的边，移动较短的边才有机会得到更大的容量。

我在这道题上踩过的坑是：一开始想当然地以为“哪边短就移动哪边”没问题，但如果两边高度相等，移动哪边都行，关键是不要两边一起动。有人会写出 left++ 同时 right-- 的版本，那就把中间的可能解跳过了。

5.5 二分答案经典题：在D天内送达包裹的能力

这个题非常典型地展示了二分答案的完整流程。给定一个重量数组 weights 和天数 D，要求把包裹按顺序分成 D 天运完，问每天运载能力的最小值。

cpp复制bool check(vector<int>& weights, int capacity, int D) {
    int days = 1, cur = 0;
    for (int w : weights) {
        if (cur + w > capacity) {
            days++;
            cur = w;
            if (days > D) return false;
        } else {
            cur += w;
        }
    }
    return true;
}

int shipWithinDays(vector<int>& weights, int D) {
    int left = *max_element(weights.begin(), weights.end());
    int right = accumulate(weights.begin(), weights.end(), 0);
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (check(weights, mid, D)) right = mid;
        else left = mid + 1;
    }
    return left;
}

这里 left 的初始值不是 0，而是单个包裹的最大重量，因为载重低于它时肯定运不了某个包裹；right 的初始值是所有包裹重量和，即一天运完的情况。check 函数里用贪心思想模拟连续搬运过程，注意 days 从 1 开始计数，而不是 0。

二分的边界条件建议自己多推几遍：当 check(mid) 返回 true（当前载重可行）时，我们尝试更小的载重，所以收缩右边界；当返回 false 时，说明载重不够，只能增大左边界。这个逻辑对“求可行解的最小值”类问题通用。

5.6 高频易错点总盘点

最后列一个我刷题过程中反复踩、也经常在帮别人 review 代码时看到的易错点清单，建议放在复习的最后一天再过一遍：

这几条如果你看一眼就能反应过来，那基础部分基本稳了；如果有一条卡住了，建议回到对应章节把那一段重新推一遍。基础算法这种东西，眼高手低是最大的敌人，看懂了不算会，能闭着眼推边界才算真的会了。

最后再分享一个我自己的复习顺序：先花半小时把所有模板手写一遍，再针对每个模板找一两道经典题练手，最后把易错点做成上面这样的表格打印出来，考前只看表格。这五个算法虽然简单，但它们的组合用法和边界细节，是真正决定笔试基础分能不能拿满的关键。