学习路线

数字 ↔ 字符串 ↔ 字符 转换套路

1. int → String

String s = String.valueOf(num);

2. String → char[] 字符数组

char[] arr = s.toCharArray();

3. 数字字符 → int 数值（超级高频！）

int d = ch - '0';

4. char[] → String

String res = new String(arr);

字符串‑数字转换(4)

1. int转字符串 String.valueOf(num)
2. 字符串拆字符数组 toCharArray()
3. 字符数字转int ch-'0'
4. char数组转回字符串 new String(arr)

字符串(1)

5. toLowerCase() / +32大小写转换

数组(1)

6. .length / .length() 区分

HashMap计数(2)

7. getOrDefault 计数自增
8. 先统计、后更新的顺序套路

数学(1)

9. Math.abs()

双指针(3)

10. 左右对撞指针（反转字符串）
11. 快慢指针判环
12. 快慢指针找环入口

二分(2)

13. 基础二分模板
14. 带开关的边界二分

链表(1)

15. 链表遍历 ptr = ptr.next

SQL(2)

16. NULL判断、AND OR筛选

字符串操作

5. 大写转小写

s.toLowerCase()

手动版公式：c + 32（前提先判断 c >= 'A' && c <= 'Z'）

数组套路

6. 数组长度

arr.length      //数组，无括号
str.length()    //字符串，带括号

LC1470 重新排列数组（新动计划第 16/20 题）

• 题目链接：https://leetcode.cn/problems/shuffle-the-array/
• 难度：简单 ｜ 专题：数组
• 一句话思路：交错重排 = 偶数位填前半段、奇数位填后半段，一次循环填两格
• 掌握程度：已独立 AC ✅

完整可提交代码

class Solution {
    public int[] shuffle(int[] nums, int n) {
        int[] result = new int[2 * n];        // 新数组
        for (int i = 0; i < n; i++) {
            result[2 * i] = nums[i];          // 偶数位 ← 前半段第 i 个
            result[2 * i + 1] = nums[n + i];  // 奇数位 ← 后半段第 i 个
        }
        return result;
    }
}

具象推演（nums = [2,5,1,3,4,7], n = 3）

i	result[2i]=nums[i]	result[2i+1]=nums[n+i]	结果
0	result[0]=2	result[1]=3	[2,3,0,0,0,0]
1	result[2]=5	result[3]=4	[2,3,5,4,0,0]
2	result[4]=1	result[5]=7	[2,3,5,4,1,7] ✅

踩坑记录（本次学习重点）

1. ❌ 交换法不行：交错重排不是两两交换，交换会把元素放错家（7 跑到位置 1）
2. ❌ i <= n 越界：数组 2n 个元素，最大索引 2n-1；nums[l+i+1] 在 i=n-1 时访问 nums[2n] 崩溃
3. ✅ 边界公式：i 从 0 开始数 n 次 → 条件永远写 i < n
4. ✅ 新数组 + 填空：2*i 是偶数位、2*i+1 是奇数位，正好交错

语法要点

• int[] result = new int[2 * n] 创建数组，格子初始为 0
• 数组索引从 0 开始，访问 nums.length 个元素时索引是 0 ~ length-1

LC867 转置矩阵（新动计划第 17/20 题）

• 题目链接：https://leetcode.cn/problems/transpose-matrix/
• 难度：简单 ｜ 专题：矩阵 / 二维数组
• 一句话思路：转置 = 行变列，下标对调 result[j][i] = matrix[i][j]
• 掌握程度：已独立 AC ✅（二维数组入门题）

完整可提交代码

class Solution {
    public int[][] transpose(int[][] matrix) {
        int rows = matrix.length;         // 原矩阵行数 m
        int cols = matrix[0].length;      // 原矩阵列数 n

        int[][] result = new int[cols][rows];  // 转置后行列对调！

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                result[j][i] = matrix[i][j];  // 下标对调
            }
        }
        return result;
    }
}

踩坑记录

1. 新数组行列对调：new int[cols][rows]，写反了越界
2. 下标对调：result[j][i] 不是 result[i][j]
3. 二维数组语法：matrix.length 是行数，matrix[0].length 是列数

语法要点（二维数组入门）

• int[][] matrix = {{1,2,3},{4,5,6}} 外层行、内层列
• matrix[i][j]：第一个下标是行，第二个是列
• 记忆：转置像换电影院座位——排和号对调

LC1422 分割字符串的最大得分（新动计划第 18/20 题）

• 题目链接：https://leetcode.cn/problems/maximum-score-after-splitting-a-string/
• 难度：简单 ｜ 专题：字符串 / 前缀增量
• 一句话思路：先数全串 1 的个数，再逐刀切，每刀只调整一个字符（0 进左计数++ / 1 出右计数--）
• 掌握程度：已独立 AC ✅

完整可提交代码

class Solution {
    public int maxScore(String s) {
        int n = s.length();
        int totalOnes = 0;
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == '1') totalOnes++;
        }
        int max = 0;
        int leftZeros = 0;
        int rightOnes = totalOnes;
        for (int i = 0; i < n - 1; i++) {   // i 只到 n-2：右边必须非空
            if (s.charAt(i) == '0') leftZeros++;
            else rightOnes--;
            max = Math.max(max, leftZeros + rightOnes);  // 亮点：max 直接维护
        }
        return max;
    }
}

核心技巧（这次学到的）

1. 增量更新：暴力是每个分割点重新数一遍 O(n²)；优化后每刀只处理一个字符的归属变化 O(n)
2. Math.max 维护最大值：max = Math.max(max, 当前值) 一行搞定，省掉 if 判断
3. 与 LC1512 同源：先统计一次全局，再增量更新（先统计后更新的升级版）

易错点

• i < n - 1：右边必须留至少 1 个字符，i 不能到 n-1
• 先更新计数再算分：这一刀切的字符归属要先"翻"过来

高频踩坑：数组 length vs 字符串 length()

踩坑记录：LC1470、LC1422 都栽在这里 —— 数组 .length 不带括号，字符串 .length() 带括号

完整规则

东西	写法	原因
数组	arr.length（无括号）	数组是 Java 语言内建类型，length 是属性（字段）
字符串 String	s.length()（有括号）	String 是普通类，length() 是方法
ArrayList	list.size()（有括号）	普通类，方法
HashMap / HashSet	map.size()（有括号）	普通类，方法
字符数组转回	new String(arr)（无括号）	构造器语法，不是取长度

为什么数组特殊？

数组不是"类"——它是 Java 语言层面的内建类型（和 int、double 同级），length 是 JVM 里直接存的字段，不需要调用方法。而 String、ArrayList 是正经的类，一切通过方法访问。

一口诀

只有数组的 length 是属性，其他一切"长度/大小"都是方法

拿不准时：先默认带括号，只有面对数组才去掉。

同类"一对多"混淆（预防）

• 数组取元素 arr[i]（下标语法）vs 字符串取字符 s.charAt(i)（方法）
• s.toCharArray() 返回数组 → 之后用 .length（无括号）
• 数组 new int[5] 创建 vs 字符串 new String(arr) 转换

记忆锚点

• String.valueOf(num) → String（方法，有括号）
• s.toCharArray() → char[]（方法，有括号）
• 一旦到了 char[] arr，取长度就是 arr.length（数组，无括号）

链条记忆：方法返回数组的那一刻，length 就变成了属性。

LC2586 统计范围内的元音字符串数（新动计划第 19/20 题）

• 题目链接：https://leetcode.cn/problems/count-the-number-of-vowel-strings-in-range/
• 难度：简单 ｜ 专题：字符串
• 一句话思路：顺序遍历区间 [left, right]，统计"首尾都是元音"的单词
• 掌握程度：已独立 AC ✅（编译错误三连修正后通过）

完整可提交代码

class Solution {
    public int vowelStrings(String[] words, int left, int right) {
        String vowels = "aeiou";
        int count = 0;
        for (int i = left; i <= right; i++) {
            String word = words[i];
            char first = word.charAt(0);
            char last = word.charAt(word.length() - 1);
            if (vowels.indexOf(first) != -1 && vowels.indexOf(last) != -1) {
                count++;
            }
        }
        return count;
    }
}

套路

1. 判断字符是否元音："aeiou".indexOf(ch) != -1（找到了返回位置，找不到返回 -1）
2. String 取字符用 charAt(i)，Java 的 String 不是字符数组，不能下标访问
3. 遍历下标区间 → for 循环（不要用双指针从两端夹，会漏中间元素）
4. 首尾都满足条件 → &&，不是 ||

踩坑：编译错误三连（本次重点）

1. 单引号 vs 双引号：字符串必须双引号 "aeiou"，单引号只能包一个字符 'a'
2. 字符 vs 数字：int count = 0（数字不带引号）；'0' 是字符，值是 ASCII 48
3. 漏括号：word.length() 是方法必须带括号（数组 .length 才不带）
4. 变量名拼写要一致（vowles vs vowels 会报"找不到符号"）

口诀：双引号包字符串，单引号包单个字符；数字不带引号，字符才带引号

哈希表计数模板（LC1512）

7. 频次+1 标准一行写法

cnt.put(num, cnt.getOrDefault(num,0)+1);

拆解底层：判断是否存在、取旧值、+1、存回去

8. 先累加再更新（好数对顺序不能颠倒）

res += cnt.getOrDefault(num,0);
cnt.put(num, cnt.getOrDefault(num,0)+1);

HashMap API 速记（哈希表三件套）

补课来源：热题 100 第一题 twoSum 复习时暴露的 API 记忆问题

三件套（背下来）

map.containsKey(key)   // 判断 key 在不在 → true/false（拼写：contains KEY！）
map.get(key)           // 取 key 对应的 value
map.put(key, value)    // 存 key -> value

常见错误

1. contains 拼错：是 containsKey，不是 countains / contains
2. 数组没有这些方法：HashMap 是 Map 接口的实现，数组是 int[]，两者完全不同
3. 声明：Map<Integer, Integer> map = new HashMap<>()（key 和 value 都要写类型）

for-each vs 普通 for 的选择

场景	用哪个	例子
需要下标	普通 for for (int i = 0; i < arr.length; i++)	twoSum 返回下标
只要值	for-each for (int num : arr)	求和、计数

记忆：要下标 → 普通 for；不要下标 → for-each

哈希模板回顾（LC1 / LC1512 通用）

// 先查（读旧状态），后存（写新状态）——顺序不能反！
if (map.containsKey(x)) { ... }
map.put(nums[i], i);

LC49 字母异位词分组（热题 100，2026-08-16）

• 题目链接：https://leetcode.cn/problems/group-anagrams/
• 难度：中等 ｜ 专题：哈希表 + 排序归一
• 一句话思路：字符串排序结果当 key，相同的归为一组
• 掌握程度：已 AC（照抄，新 API 需复习巩固）

完整代码

import java.util.*;

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();
        for (String word : strs) {
            char[] arr = word.toCharArray();
            Arrays.sort(arr);
            String key = new String(arr);
            if (!map.containsKey(key)) {
                map.put(key, new ArrayList<>());
            }
            map.get(key).add(word);
        }
        return new ArrayList<>(map.values());
    }
}

本次新 API 清单（需复习）

新 API	说明
Arrays.sort(arr)	数组原地排序（字符串三步走第二步）
new ArrayList<>()	创建空列表（分组容器）
list.add(x)	往列表末尾加元素
map.values()	取出所有分组，转成 List 返回
Map<String, List<String>>	声明：key=字符串，value=字符串列表

核心套路：排序归一

判断一组东西"本质上是否相同" → 排个序 → 排序结果当 key

与 LC242 验证异位词同源（那边用计数当 key，这边用排序当 key，都行）

复习计划

明天不看答案，从空文件重写一遍——写不出的部分就是还没记住的 API，单独背。

数学工具方法

9. 取绝对值

Math.abs(x)

双指针模板

10. 反转数组左右指针

int left = 0, right = s.length-1;
while(left < right){
    swap
    left++;right--;
}

11. 快慢指针链表（141、142 环形链表）

• 检测环：slow 一次 1 步，fast 一次 2 步
• 找环入口：相遇之后，一个指针从头、一个从相遇点，同速走

LC852 山脉数组的峰顶索引（新动计划第 20/20 题 · 毕业题）

• 题目链接：https://leetcode.cn/problems/peak-index-in-a-mountain-array/
• 难度：中等 ｜ 专题：二分查找（拐点二分）
• 一句话思路：比较相邻元素判断上下坡，用 while (left < right) + right = mid 模板收缩到峰顶
• 掌握程度：已独立 AC ✅（新动计划毕业题）

完整可提交代码

class Solution {
    public int peakIndexInMountainArray(int[] arr) {
        int left = 0, right = arr.length - 1;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] < arr[mid + 1]) {
                left = mid + 1;   // 上坡：峰顶在右边，mid 可排除
            } else {
                right = mid;      // 下坡：mid 可能就是峰顶，不能排除！
            }
        }
        return left;
    }
}

核心：为什么 right = mid 不是 mid - 1

能不能证明 mid 不是答案？

• 上坡 arr[mid] < arr[mid+1]：mid 右边有更大的，mid 不可能是峰顶 → 排除 → left = mid + 1
• 下坡 arr[mid] > arr[mid+1]：mid 可能就是峰顶（如 [0,1,2,1,0] 中 mid=2） → 不能排除 → right = mid

标准二分（找值）里 mid 已被验证"不是 target"，所以敢 mid ± 1；拐点二分里下坡的 mid 可能是答案，只能收缩不能跳过。

二分武器库（现在有两把了）

	找值二分（LC704/35/34）	拐点二分（LC852）
目标	找 target	找转折点/峰顶
循环	while (left <= right)	while (left < right)
更新	left = mid+1 / right = mid-1	left = mid+1 / right = mid
排除逻辑	mid 已验证非答案	上坡排除 mid，下坡保留 mid
结束	left 越过 right	left == right 汇合

记忆锚点

• 找值 → <= + 两边都跳过 mid（排除式）
• 找拐点 → < + 一边跳过、一边保留 mid（保留式）
• 判断标准：能不能证明 mid 不是答案

二分查找基础模板（704、35、34）

12. 标准二分

int left=0, right=nums.length-1;
while(left <= right){
    int mid = (left+right)/2;
}

13. 左右边界二分开关模板（boolean lower）

链表基础

14. 从头遍历链表

ListNode ptr = head;
while (ptr != null) {
    // 处理当前节点
    ptr = ptr.next;
}

LC1 两数之和

• 题目链接：https://leetcode.cn/problems/two-sum/
• 难度：简单 ｜ 专题：哈希表
• 一句话思路：边走边记，等另一半出现（target - num）

完整可提交代码

import java.util.HashMap;
import java.util.Map;

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // map 记录：值 -> 下标（先查后存）
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i]; // 需要的另一半
            if (map.containsKey(complement)) {
                return new int[]{map.get(complement), i};
            }
            map.put(nums[i], i); // 没等到，先把自己记下来
        }
        return new int[]{}; // 题目保证有解，走不到这里
    }
}

具象推演

nums = [2, 7, 11, 15], target = 9

步骤	当前数字	需要的另一半	表里有吗？	动作
i=0	2	9-2=7	否（空表）	记 2 → 0
i=1	7	9-7=2	有！（2→0）	返回 [0, 1]

高频坑点

1. 必须先查、后存：先 put 再查会命中自己 —— nums=[3,3], target=6 时错误返回 [1,1]（同一个元素用两次）
2. 与 LC1512 同一套路：先读旧状态，再写新状态

掌握程度

• 已理解 ✅（待独立 AC 后勾选）

完成：

• 第1周验收：独立写九九乘法表 + 带返回值方法求和（已通过）
• 面向对象：学类与对象+构造方法，定义 Student 类并创建对象
• 面向对象：学封装（private + getter/setter），给 Student 加字段访问控制
• C线算法：刷 1-2 题（数组/链表专题，恢复手感）
• 用 Git 把 学习中创建的java文件推到 GitHub （由 dsh 计划面板自动记录）

完成：

• 第1周验收：独立写九九乘法表 + 带返回值方法求和（已通过）
• 面向对象：学类与对象+构造方法，定义 Student 类并创建对象
• 面向对象：学封装（private + getter/setter），给 Student 加字段访问控制
• C线算法：刷 1-2 题（数组/链表专题，恢复手感）
• 用 Git 把 学习中创建的java文件推到 GitHub （由 dsh 计划面板自动记录）

完成：

• 第1周验收：独立写九九乘法表 + 带返回值方法求和（已通过）
• 面向对象：学类与对象+构造方法，定义 Student 类并创建对象
• 面向对象：学封装（private + getter/setter），给 Student 加字段访问控制
• C线算法：刷 1-2 题（数组/链表专题，恢复手感）
• 用 Git 把 学习中创建的java文件推到 GitHub （由 dsh 计划面板自动记录）

完成：

• 面向对象·继承：定义 Animal 父类（如 name/eat），写 Dog、Cat 继承它并覆写方法，独立写出来能编译运行
• C线算法：刷1-2题（数组/链表专题）恢复手感
• 跑通后把 java 文件用 Git 推到 GitHub（记得先 export HTTPS_PROXY=http://127.0.0.1:7897）
• 在博客学习页打个今天回归的卡 （由 dsh 计划面板自动记录）