Java刷题避坑指南：从环境配置到力扣30题的方法论

别人刷题是越刷越上头，我刚开始用 Java 刷力扣的时候，是越刷越怀疑人生。语法学了一堆，集合框架也能背出几个，可真到了编辑器里，面对一道标着“简单”的题，经常连第一步该干什么都想不清楚。后来我才意识到，问题不在于刷得少，而在于我用错了方法——一上来就追难题、追题量，笔记倒是存了一堆题解，真正过脑子的没几道。这篇文章就是我整理给自己、也整理给同样在起步阶段的 Java 开发者的“最容易上手版”刷题笔记。它不会一上来就扔动态规划，也不会让你背一堆八股，而是从环境准备、第一道题怎么啃、笔记怎么记，到高频问题怎么排查，一步步把刷题这件事变得可持续。如果你刚学完 Java 基础，或者刷了一阵子力扣但总觉得自己在原地踏步，这篇内容应该能帮你在前 30 道题里少走很多弯路。

1. 刷题前的准备：环境、工程与打底知识点

1.1 JDK 版本怎么选，以及为什么不用纠结

很多人还没开始刷题，先被“装哪个 JDK”卡住了。打开搜索引擎，Java 8、Java 11、Java 17、Java 21 各有各的道理，教程越多越不知道听谁的。

我的建议很简单：如果你没有历史项目拖着，直接装一个 LTS 版本，比如 Java 17。原因有三个：第一，力扣的在线编辑器对 Java 17 的支持已经很成熟，日常刷题用到的语法特性它全都有；第二，Java 17 之后的版本在性能、内存管理上明显更省心，本地跑测试用例不容易遇到奇怪的内存问题；第三，大部分公司的主流项目早就从 Java 8 往上升级了，你刷题用的版本贴近生产环境，后面面试聊起来也不会有“我只会 Java 8”的尴尬。

至于网上常说的 Java 8 和 Java 17 在 switch 表达式、var、文本块这些语法上的差异，刷题阶段你基本用不到。真正需要记住的只有一件事：本地装好后，命令行里执行 java -version 和 javac -version 都能正常输出，说明环境没问题。这个验证步骤很基础，但我见过太多人装了 IDE 就直接写代码，结果 javac 根本不在 PATH 里，编译报错了还以为是代码问题。

提示：环境变量配置里最容易出错的是 JAVA_HOME。配置时不要直接指向 JDK 安装目录的 bin 文件夹，而是指向 JDK 的根目录。比如 Windows 上安装路径是 C:\Program Files\Java\jdk-17，JAVA_HOME 就填这个路径，然后在 PATH 里加 %JAVA_HOME%\bin。配置完一定要重开命令行窗口再验证，否则环境变量不会生效。

1.2 本地建一个最简单的刷题工程

我见过两种极端：一种是从头到尾只在力扣网页上写，提交通过了就关掉页面，代码不留档；另一种是一上来就开 Spring Boot 工程，为了刷一道“两数之和”启动了半天的应用。两种都不太合适。

正确做法是本地建一个没有任何框架依赖的纯 Java 工程。目录结构可以非常朴素：

text复制leetcode-java/
├── src/
│   └── main/
│       └── java/
│           └── solutions/
│               ├── P0001_TwoSum.java
│               ├── P0014_LongestCommonPrefix.java
│               └── ...
└── src/
    └── test/
        └── java/
            └── solutions/
                └── P0001_TwoSumTest.java

每个题一个类，类名用 P题号_题名 这种格式，一眼就知道是哪道题。如果用 IDE（IntelliJ IDEA 或者 VS Code 都行），直接建一个普通 Java 项目，不要勾选 Maven 或 Gradle 模板。刷题阶段的依赖基本只有 JDK 自带的类库，引入构建工具纯属给自己增加负担。

在这个工程里，我会在代码文件里保留三样东西：题目描述的关键信息、我的解题思路注释、完整的测试用例。比如下面这类模板就很实用：

java复制package solutions;

public class P0001_TwoSum {

    // 题目：给定一个整数数组 nums 和一个整数目标值 target，
    // 请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。
    // 假设每种输入只会对应一个答案，且同一个元素不能使用两遍。

    // 思路：用 HashMap 记录“值 -> 下标”，一次遍历。
    // 每到一个数，先查 target - nums[i] 是否已经在 map 里。
    // 如果在，说明找到了答案，直接返回两个下标。
    // 如果不在，把当前值和下标放进去，继续往后走。

    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int need = target - nums[i];
            if (map.containsKey(need)) {
                return new int[]{map.get(need), i};
            }
            map.put(nums[i], i);
        }
        return new int[0];
    }
}

本地保留完整的注释和测试代码，不是多此一举。刷题最有价值的部分不是提交通过那一刻的爽感，而是过了两三个星期后回看这道题，还能不能根据注释快速回忆起当时的思考过程。

1.3 真正用得上的 Java API，先混个脸熟

“数据结构没学完，是不是不能开始刷题？”这是新手最爱问的问题。我的回答很直接：不用等学完，先记住最常用的那十几个 API，边刷边补。

最开始你只需要这几样：

• 数组：int[]、char[]，访问用 arr[i]，长度是 arr.length。注意这不是方法，没有括号。
• 字符串：String 的 length()、charAt(i)、substring(start, end)、indexOf()、equals()、toCharArray()。字符串刷题出场率极高，尤其是子串、前缀、回文这类题。
• 列表：ArrayList 和 LinkedList，常用 add()、get(i)、size()、remove()。注意 List 是接口，不能直接 new List<>()。
• 哈希表：HashMap，常用 put()、get()、containsKey()、getOrDefault()。两数之和、字母异位词分组这类题全靠它。
• 栈和队列：Java 里用 Deque 接口，实现类选 ArrayDeque 或 LinkedList。栈操作用 push()、pop()、peek()，队列操作用 offer()、poll()、peek()。
• 排序：Arrays.sort() 对数组排序，Collections.sort() 对 List 排序。很多暴力解法配合排序之后，效率能上一个大台阶。

我把这些 API 整理成一个速查表，刷题卡住的时候先看表，不要凭感觉猜：

注意：Java 里还有一个 Stack 类，但官方文档已经建议不要再用了，它继承了 Vector，性能差而且接口设计有问题。刷题时看到题解里用 Stack 的，可以直接替换成 Deque 配合 ArrayDeque 实现。

1.4 用四个特征判断一道题是否“容易上手”

刚开始刷题，选错题比不够努力更打击人。我总结了四个特征，符合这些特征的题才适合放在起步期：

第一，题干短。一道题的描述如果超过三行，你要先花十分钟理解它在说什么，新手很容易在阅读理解阶段就耗光耐心。第二，不依赖冷门算法。不用前缀树、不用图论、不用复杂的动态规划，用基础数据结构和循环就能解决。第三，暴力解法能跑通。哪怕效率不高，至少能保证“先做出来”，这一点给新手的信心比什么都重要。第四，题解区讨论量大。讨论多意味着解法多样、坑点多，你能从别人的思路里学到不少东西。

用这个标准去筛力扣的题目，“两数之和”（第 1 题）、“有效的括号”（第 20 题）、“最长公共前缀”（第 14 题）、“删除有序数组中的重复项”（第 26 题）都很合适。我自己的前 10 道题基本都在这类简单题里打转，等把循环、数组、字符串、哈希表这些基础操作练熟了，再去碰中等题，感受会完全不一样。

2. 手把手啃下第一道题：最长公共前缀

2.1 读题阶段：先圈出题眼，而不是急着写代码

以力扣第 14 题“最长公共前缀”为例，题目是：编写一个函数来查找字符串数组中的最长公共前缀，如果不存在公共前缀，返回空字符串 ""。示例是 ["flower","flow","flight"] 返回 "fl"，["dog","racecar","car"] 返回 ""。

我刚开始刷题时，看到这题第一反应是“这有什么好做的”，然后直接去写代码，结果写了一版乱七八糟的嵌套循环，提交后边界情况错了一大片。后来我学乖了，先把题眼圈出来。这道题的题眼有三个：

第一，“前缀”，意味着公共部分必须是从每个字符串的开头开始算，而不是任意的公共子串。很多人在这一点上理解偏差，后来写出包含字符串中间的公共部分，题目就理解错了。第二，“所有字符串”，也就是说这个公共前缀必须同时存在于数组里的每一个字符串中，不是两两之间，而是全体之间的交集。第三，题目还补充了边界条件，如果数组为空，返回空字符串，这个条件很多题解里不会明说，但测试用例会覆盖。

读题时把题眼写在草稿纸上，远比直接开始写代码重要。你会发现，大多数简单题真正卡住你的不是代码能力，而是题目理解不到位。

2.2 从暴力思路起步，先保证做出来

对于这道题，最容易理解的方法是纵向扫描。想象把这些字符串竖着排成一列，然后从第一个字符开始，一列一列往下比较。所有字符串的第 0 个字符都相同，就继续比较第 1 个；一旦发现某个字符串的长度不够了，或者某个字符和其他字符串不一样了，那当前位置之前的部分就是最长公共前缀。

用生活化的比喻来说，就像一排人并排站在一起，你从前面看过去，先看各自的刘海一样不一样，再看各自的眉毛一样不一样。等你发现有人在某一层已经“秃了”没头发了，或者发色不一样了，那前面那些一致的部分就是公共前缀。

按照这个思路，代码很简单：

java复制public String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0) {
        return "";
    }

    // 用第一个字符串作为基准，逐个字符向后比较
    for (int i = 0; i < strs[0].length(); i++) {
        char c = strs[0].charAt(i);

        // 拿第 i 个字符去和其他所有字符串比较
        for (int j = 1; j < strs.length; j++) {
            // 如果某个字符串已经到头了，或者第 i 个字符不匹配
            if (i >= strs[j].length() || strs[j].charAt(i) != c) {
                // 前面 i 个字符就是最长公共前缀
                return strs[0].substring(0, i);
            }
        }
    }

    // 执行到这里说明第一个字符串本身就是所有字符串的公共前缀
    return strs[0];
}

注意代码里的判断顺序：先检查 i >= strs[j].length()，再比较字符。这里必须把越界检查放在前面，因为 Java 的逻辑或 || 是短路运算符，左边为 true 时右边不会执行。如果你先把 strs[j].charAt(i) 写在前面，遇到长度不够的字符串，会直接抛出 StringIndexOutOfBoundsException。

2.3 真正值钱的边界测试用例，一定自己跑一遍

很多人写完代码，看一眼示例没问题就提交，结果被隐藏测试用例打得满头包。我自己总结了一套简单题的必测用例清单，每道题写完后都要过一遍：

这些用例不是拍脑袋想出来的，它们分别覆盖了代码里的每一个 return 分支和最容易出错的边界条件。我在本地跑的时候，会把这些用例全部写成 main 方法里的断言，或者直接打印出来肉眼对比：

java复制public static void main(String[] args) {
    P0014_LongestCommonPrefix solution = new P0014_LongestCommonPrefix();
    System.out.println(solution.longestCommonPrefix(new String[]{"flower", "flow", "flight"})); // fl
    System.out.println(solution.longestCommonPrefix(new String[]{"dog", "racecar", "car"}));     // 空
    System.out.println(solution.longestCommonPrefix(new String[]{}));                              // 空
    System.out.println(solution.longestCommonPrefix(new String[]{"a"}));                           // a
    System.out.println(solution.longestCommonPrefix(new String[]{"abc", "abc", "abc"}));          // abc
    System.out.println(solution.longestCommonPrefix(new String[]{"flower", "flower", "flow"}));   // flow
    System.out.println(solution.longestCommonPrefix(new String[]{"", "b"}));                      // 空
}

当你把这种“写用例”变成习惯，以后再写中等题和难题时，调试时间会大幅缩短。说句实话，算法题里你提交后报错的大多数情况，都是没想清楚某个边界条件导致的。

2.4 复杂度分析和一题多解，别等到面试才学

这道题纵向扫描的时间复杂度是 O(mn)，其中 n 是字符串数组的长度，m 是字符串的平均长度。因为最坏情况下，你需要遍历所有字符串的每个字符。空间复杂度是 O(1)，除了存储答案用的变量，没有额外开辟大块内存。

但面试里光是会这一种解法是不够的。力扣题解区最常见的另一种做法是横向扫描：先取第一个字符串作为初始公共前缀，然后拿它依次和后面的字符串求交集，每比较一次就把前缀缩短一点。代码比纵向扫描更短：

java复制public String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0) {
        return "";
    }
    String prefix = strs[0];
    for (int i = 1; i < strs.length; i++) {
        while (strs[i].indexOf(prefix) != 0) {
            prefix = prefix.substring(0, prefix.length() - 1);
            if (prefix.isEmpty()) {
                return "";
            }
        }
    }
    return prefix;
}

横向扫描里最核心的操作是 strs[i].indexOf(prefix)。indexOf 方法返回子串在原字符串中第一次出现的位置，如果返回值不等于 0，说明这个前缀根本不以它为开头，于是把前缀末尾的字符砍掉，再试。直到前缀变成空字符串，说明没有公共前缀。我当时第一次看到这种写法时觉得特别精妙——它不再一个字符一个字符地比较，而是把“比对”这件事交给了 JDK 封装好的方法。

面试官很喜欢让你比较这两种解法的优劣。纵向扫描理论上更清晰，不容易出错；横向扫描代码更简洁，而且可以利用 JDK 原生方法的高性能实现。两者时间复杂度一样，但在字符串内容差异较大时，横向扫描往往能更早退出循环。能在白板上把两种写法都讲清楚，比背十道题的答案更能体现你真正理解了题目。

3. 打造一套适合自己的刷题笔记系统，做到持续更新

3.1 为什么答案抄了十道，还是感觉什么都没学会

很多人刷题的流程是这样的：打开一道题，想了五分钟没思路，点开题解，看懂了之后复制粘贴提交，然后心满意足地划到下一题。我一开始也这么干过，后来发现一个扎心的事实：这种刷法就算刷 200 道，面试时遇到稍微变形的新题，照样会卡壳。

原因在于“看懂了”和“会做了”之间有一条巨大的鸿沟。看题解时大脑会产生一种“我也能想出来”的错觉，但真正合上题解让你从头写，你会发现连第一步该定义什么变量都忘了。要想把一道题真正变成自己的，绕不开一个笨办法——用自己的话把题解讲一遍，然后合上答案重新写。

这也是我坚持做笔记的原因。每次做完一道题，我会强迫自己在笔记里回答几个问题：这道题要我干什么？我第一眼看到它时的想法是什么？这道题的正确思路是什么样的？我当时为什么没想到？这道题可以归到哪一类，以后看到类似特征可以往哪个方向想？这个过程不轻松，但效果非常明显。坚持了二十道题之后，我会发现自己看到新题时，脑海里能自动浮现出若干种可能的思路，不再是两眼一抹黑。

3.2 一个可以直接抄的笔记模板

笔记模板不用花哨，关键是能沉淀思路。我自己用的是下面这个结构：

text复制## P0014 最长公共前缀（Easy）

### 题目一句话
找到字符串数组里所有字符串共同的前缀，没有就返回空串。

### 我的第一反应
用第一个字符串当基准，跟后面每个字符串逐位比较。

### 正确解法（纵向扫描）
以第一个字符串为基准，外层循环遍历它的每个字符，
内层循环遍历其他字符串，比较同一个位置上的字符。
一旦发现某个字符串长度不够，或者字符不一致，就截断返回。

### 我没想到的点
可以用 indexOf 判断前缀是否匹配，配合 while 循环不断缩短前缀。
这样代码更少，而且能直接用 JDK 的优化实现。

### 复杂度
时间 O(mn)，空间 O(1)

### 同类题
P0028 找出字符串中第一个匹配项的下标
P0459 重复的子字符串

笔记里最关键的是“我没想到的点”这一栏，它记录了你的思维盲区。下次遇到相似场景时，我会专门翻看这些盲区，提醒自己不要在同一个坑里跌倒两次。

文件命名我建议采用“编号 + 题目 + 难度”的方式，比如 0014-longest-common-prefix-easy.md。后面按题号排序，复习时想查哪道题都能快速定位。我自己的笔记是纯 Markdown 文件，放在项目的 docs 目录下，配合 Git 做版本管理。这样既不怕电脑丢失，也能看到自己思路的演进过程。

3.3 难度分级，决定复习节奏

刷题笔记不是写完就扔的。我按照“能不能独立做出来”把题目分成三个等级，套用这套方法复习起来非常省力：

第一等级是“闭眼能做”。看到题目就能写出解法，并且能清楚地讲出思路。这类题一周快速过一眼就行，不需要反复练。第二等级是“磕磕绊绊做出来”。看过提示之后能做出来，但中间有些环节想不清楚，比如为什么这里要用哈希表而不是数组。这类题是我复习的重点，每两天重新做一遍，直到变成第一等级。第三等级是“照着答案才看懂”。这种题目暂时超出了目前水平，我不会死磕太久，但会把笔记里的“我没想到的点”写清楚，等过一两周再回来尝试。

我用一个简单的表格跟踪每道题的状态：

这个表其实就是“持续更新”四个字的落地方式。很多人以为持续更新是指每天发新内容给读者看，但对我来说，持续更新更重要的是每天刷新自己对旧题的掌握程度，这种复盘机制比单纯追题量更有价值。

3.4 怎么让“每天刷几题”这件事真正坚持下去

说句实在话，刷题最难的不是题目本身，而是“持续”这两个字。我尝试过每天刷五题的模式，结果坚持不到一周就崩了。后来接受了一个现实：对于白天要写业务代码、晚上还要抽空刷题的上班族来说，每天能稳定投入 40 到 60 分钟已经很理想了。

在这个时间段里，最合理的分配是一道新题加一道复习题。新题负责拓展思路，复习题负责巩固记忆。不要贪多，一天能真正吃透一道题，比囫囵吞枣做五道题强十倍。周末时间充裕的话，可以集中做两到三道中等难度的题，再把本周记录下来的错题统一过一遍。

另外还要注意，力扣是有每日一题的，但每日一题的难度波动很大，今天简单明天可能就是困难。我自己的策略是：每日一题如果合适就做，不合适就跳过，不要为了维持连续打卡而硬啃远超自己水平的题。打卡记录上的连续天数没有任何实际意义，身体和大脑感受到的正反馈才真正让你愿意坚持。

4. 新手刷题高频故障与 Java 常见坑排查实录

4.1 本地跑得好好的，贴到力扣却编译不过

这是新手最常遇到、也最容易被吓到的问题。本地代码运行正常，但复制到力扣编辑器里就报编译错误。仔细看报错信息，绝大多数情况都是以下三种：第一种，代码里多写了一个 public class Main。力扣已经提供了一个类名，你只需要把方法写在它给出的类里，不要再额外定义一个包含 main 方法的公开类，否则文件名和类名对不上，编译器直接报错。第二种，缺少 import 语句。比如在本地你用 IDEA，它自动帮你 import 了 java.util.*，但力扣编辑器不会自动做这件事。代码里用了 HashMap 却没写 import java.util.HashMap; 时，编译就会报找不到符号。第三种，把本地测试用的 main 方法也一起贴进去了。提交时只保留题目要求的方法即可，所有的测试代码都不用带上去。

提示：力扣编辑器其实是支持把 JDK 常用包自动导入的，但遇到 Arrays、Map 这类工具类时，我仍然建议你在代码里显式写上 import。这样你把代码贴回本地工程或者复制到其他平台时，都不会出现环境差异。养成显式导入的习惯没有成本，却能避免一系列莫名其妙的编译问题。

4.2 算法思路看着没问题，怎么一运行就数组越界

数组越界报错在初学期几乎是每天都能见到的老朋友。建议先从代码里所有访问数组的地方入手排查，尤其是循环里的下标。我把越界场景分成几个典型类型：

第一种是在循环条件里用了 i <= nums.length，正确的是 <，因为数组下标从 0 开始，最大只能到 length - 1。第二种是在循环内部继续对数组做进一步访问时，没有判断是否越界。比如你要比较 nums[i] 和 nums[i + 1]，当 i 走到最后一个元素时，i + 1 必然越界，所以循环上限要改成 nums.length - 1。第三种是字符串用 charAt(i) 时，i 超出了字符串长度减一的范围。这种情况在“某个字符串比较短”的测试用例里最容易冒出来，就像最长公共前缀那道题里的空字符串一样。

排查这类问题最快的方式不是盯着代码看，而是在本地把异常堆栈打出来。Java 的数组越界异常会明确告诉你是在源码的哪一行发生的，还会附带上数组长度和非法下标的值。有了这两个信息，回到代码里对应行看一下，通常很快就能定位。

4.3 Java 语言层面的几个经典陷阱

刷题过程中会反复遇到几个 Java 特有的坑，这里集中整理一下。

第一个是 Integer 的缓存问题。当你在代码里通过自动装箱创建 Integer 对象，并拿 == 比较时，要注意 Java 会缓存 -128 到 127 范围内的 Integer 对象。也就是说，Integer a = 127; Integer b = 127; a == b 返回 true，但换成 128 就返回 false。刷题时比较两个包装类型是否相等，一律用 equals()，别用 ==。如果你发现自己某些测试用例在数值小的时候通过、数值大的时候失败，十有八九是这个原因。

第二个是 List<List<Integer>> 的初始化。新手想创建一个嵌套列表但不会写，经常出现双重泛型报错。记住最标准的写法是 List<List<Integer>> res = new ArrayList<>();，添加一行时用 res.add(new ArrayList<>());，然后往这个新列表里加元素。千万不要尝试 new List<List<Integer>>()，因为 List 是接口，不能直接实例化。

第三个是字符串频繁拼接的性能问题。在循环里不断用 + 拼接字符串，虽然代码写起来很爽，但效率很低。初学阶段可能感觉不出来，等到处理长度几万的测试用例时，就会出现时间超限。如果你确实需要在循环里构建字符串，用 StringBuilder，这是 Java 官方推荐的方案。

第四个是集合遍历时删除元素导致的 ConcurrentModificationException。刷到一些需要“边遍历边删除”的题目时，新手往往直接在 for-each 循环里调用 list.remove()，运行就抛异常。这里有两个常见解法：要么用 Iterator 的 remove() 方法，要么用 for 循环倒着遍历删除。

这些坑有个共同特点：它们不是算法问题，而是语言熟练度问题。遇到一次记到笔记里，比在浏览器里搜十次都管用。

4.4 刷了二十道题还是没感觉，是方法出了问题吗

如果你已经认真刷了二十多道题，但做新题时依然没有思路，这不代表你笨，大概率是题目选择和学习方式需要调整。

我复盘过自己的这段时期，发现核心原因是：我只顾着“做题”，没有按“题型”去归纳总结。比如“两数之和”和“字母异位词分组”这两道题，看起来毫不相关，但都用到了同一个核心思想——用哈希表把遍历过的信息存起来，空间换时间。如果我只是孤立地做完了这两道题，没有意识到它们背后的共性，那么下次遇到“最长连续序列”这类同样需要哈希表思想的题，自然还是想不起来要用哈希表。

调整的方法是把刷题从“按题号刷”改成“按知识点刷”。比如花一周专门练哈希表相关题目，下周专门练双指针，再下周练栈和队列。每练完一个专题，找一张纸把这个专题的常用套路写下来。等专题刷多了，你会发现脑海里的知识点逐渐织成一张网，新题落到网上能自动挂到某个熟悉的节点上。这个过程没法加速，但对普通人来说非常有效。

4.5 面试导向：把刷题成果变成能说出口的东西

最后说点实际的。如果你刷题是为了准备面试，那么从第一天起就要有意识地把“闷头做题”和“开口讲题”结合起来。面试考察的是你在白板前边想边说、跟面试官沟通思路的能力，和一个人安静地写代码完全是两种状态。

我建议每做完一道题，花三分钟对着镜子或者录音软件，模拟给人讲解一遍。讲的时候要覆盖四个部分：题目的输入输出是什么；暴力解法是什么，复杂度多少；你最终采用的是什么优化思路，为什么想到它；还有没有进一步优化空间。这道题的时间复杂度是怎么算出来的，也要能当场推导。比如最长公共前缀的 O(mn)，为什么要乘起来而不是加起来，很多人在面试官追问之下会突然卡壳，因为平时从来没有真正理解过，只是背了结论。

另外建议把力扣热题 100 里与常见面试知识点重合的部分优先消化。不是因为它比别的题高级，而是因为太多面试官已经默认候选人要刷过这份清单。你可以在自己整理的题型表里，给这些题打上“高频”标签，在有限的刷题时间内优先保证这部分题做到“闭眼能做”的程度。等这些底子打牢了，面试时你会明显感觉到，即使遇到没见过的题，至少也能说出个思路轮廓，不再慌了。

我在实际的刷题过程里还有一个体会：最容易放弃的时刻通常不是遇到难题，而是某天断更之后，看着自己的进度表空出一格，第二天就不想继续了。所以我很早就给自己定了一条规矩：某天实在忙得没时间，那就只写一道题的核心思路笔记，不写代码也算完成了当天任务。这个看上去很宽松的规则，反而保证了刷题记录能够一直延续下去。毕竟学习这件事，跑得快不如跑得久，哪怕每天只前进一小段，攒上三个月再回头看，也会惊讶于自己已经走了这么远。