Java算法题核心API实战手册：数据结构、字符串与I/O优化全解析

Java算法数据结构集合框架

于 2026-08-04 07:11:05 修改

·本内容遵循CC 4.0 BY-SA版权协议

1. 项目概述：为什么我们需要一份Java算法题API手册

干了这么多年开发，也带过不少新人，我发现一个挺普遍的现象：很多朋友在刷LeetCode、准备面试或者处理日常业务中的算法逻辑时，常常会卡在一些“非核心”的环节上。比如，明明知道该用优先队列（堆），却纠结于PriorityQueue的构造器参数怎么写；或者想对数组进行复杂排序，却记不清Arrays.sort()里那个自定义Comparator的lambda表达式语法。时间就在反复查阅基础API文档中溜走了，思路也被打断得七零八落。

这份“Java算法题常用API整理总结”，就是针对这个痛点来的。它不是一个面面俱到的Java标准库文档，而是一份高度聚焦于算法竞赛、笔试面试和高效编码场景的“武器库速查手册”。核心目标就一个：让你在思考算法主逻辑时，不再被语法细节绊住脚，把精力100%投入到问题分析和方案设计上。无论是刚入门的数据结构新手，还是想提升刷题流畅度的老手，手边备着这么一份按功能分类、附有典型用法的清单，效率提升是立竿见影的。接下来，我们就抛开那些冗长的理论，直接进入实战，看看在Java的世界里，有哪些API是你解算法题时真正离不开的“神兵利器”。

2. 核心数据结构类API精讲与避坑指南

算法题的本质是对数据的组织和操作，而Java集合框架（Java Collections Framework, JCF）就是我们最趁手的工具箱。这里重点讲几个在算法题中出现频率极高，且容易用错的类。

2.1 数组（Array）与工具类Arrays

数组是基础中的基础，虽然简单，但配合java.util.Arrays工具类，能玩出很多花样。

核心API速览：

Arrays.sort(): 排序。这是算法题里的“万金油”。
Arrays.binarySearch(): 二分查找。前提是数组有序。
Arrays.copyOf() / Arrays.copyOfRange(): 数组拷贝。比用循环自己写更安全高效。
Arrays.fill(): 填充数组。
Arrays.equals() / Arrays.deepEquals(): 比较数组内容。
Arrays.asList(): 将数组转为List视图。这里有个大坑！

排序的进阶用法： 默认的Arrays.sort()对基本类型数组使用双轴快速排序，对对象数组使用TimSort，时间复杂度为O(n log n)。但在算法题中，我们经常需要自定义排序规则。

JAVA

// 1. 对普通数组排序

int[] nums = {3, 1, 4, 1, 5};

Arrays.sort(nums); // [1, 1, 3, 4, 5]

// 2. 对自定义对象数组排序（实现Comparable接口）

class Point implements Comparable<Point> {

int x, y;

// ... 构造方法等

@Override

public int compareTo(Point o) {

return this.x != o.x ? this.x - o.x : this.y - o.y; // 先按x升序，再按y升序

}

Point[] points = ...;

Arrays.sort(points);

// 3. 使用Comparator进行灵活排序（更常用！）

int[][] intervals = {{1,3}, {2,6}, {8,10}, {15,18}};

// 按区间起点升序排序

Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

// 更安全的写法，防止整数溢出

Arrays.sort(intervals, Comparator.comparingInt(a -> a[0]));

// 4. 复杂排序：例如，按字符串长度排序，长度相同则按字典序

String[] words = {"cat", "banana", "apple", "bat"};

Arrays.sort(words, (a, b) -> {

if (a.length() != b.length()) {

return a.length() - b.length();

} else {

return a.compareTo(b);

}

});

注意： Arrays.asList()返回的List是一个固定大小的视图，不支持add()或remove()等结构性修改操作，调用会抛出UnsupportedOperationException。如果需要一个可变的List，请使用new ArrayList<>(Arrays.asList(...))。

2.2 动态数组ArrayList

ArrayList是我们最常用的动态数组，提供O(1)的随机访问和O(n)的中间插入/删除。

算法题高频操作：

add(E e) / add(int index, E e)
get(int index)
set(int index, E e)
remove(int index) / remove(Object o)
size()
isEmpty()
clear()
contains(Object o): O(n)复杂度，频繁判断包含请考虑HashSet。
subList(int fromIndex, int toIndex): 获取子列表视图，修改子列表会影响原列表。

初始化与性能陷阱：

JAVA

// 好的实践：如果知道大致大小，初始化时指定容量，避免多次扩容拷贝

List<Integer> list = new ArrayList<>(1000);

// 需要警惕的操作：在循环中通过索引删除元素

for (int i = 0; i < list.size(); i++) {

if (someCondition) {

list.remove(i); // 删除后，后续元素索引前移，i++会导致跳过一个元素！

i--; // 必须手动修正索引

}

// 更安全的做法：使用迭代器或从后往前遍历

for (int i = list.size() - 1; i >= 0; i--) {

if (someCondition) {

list.remove(i);

}

2.3 哈希表HashMap与HashSet

HashMap（键值对）和HashSet（唯一元素集合）提供了平均O(1)时间复杂度的查找、插入和删除，是解决“查找”、“去重”、“计数”类问题的利器。

HashMap核心API：

put(K key, V value)
get(Object key)
getOrDefault(Object key, V defaultValue): 强烈推荐，避免空指针和繁琐的containsKey判断。
containsKey(Object key) / containsValue(Object value)
keySet() / values() / entrySet(): 遍历时常用。
remove(Object key)
size()

典型算法应用场景：

两数之和（Two Sum）：遍历数组，用Map存储<数值，索引>，查找target - current。
统计元素频率：Map<Integer, Integer> freq = new HashMap<>(); freq.put(num, freq.getOrDefault(num, 0) + 1);
充当简易缓存或记忆化（Memoization）存储：在递归或动态规划中存储中间结果。

HashSet核心API：

add(E e): 添加元素，如果已存在则返回false。
remove(Object o)
contains(Object o)
size()

使用技巧与坑点：

JAVA

// 1. 遍历HashMap的几种方式（推荐entrySet，效率最高）

Map<String, Integer> map = new HashMap<>();

for (Map.Entry<String, Integer> entry : map.entrySet()) {

String key = entry.getKey();

Integer value = entry.getValue();

// ...

}

// 或者（如果只需要键或值）

for (String key : map.keySet()) { ... }

for (Integer value : map.values()) { ... }

// 2. 自定义对象作为Key

// 必须重写hashCode()和equals()方法，否则无法正确工作。

class Student {

String id;

String name;

@Override

public int hashCode() { return Objects.hash(id, name); }

@Override

public boolean equals(Object obj) { ... } // 按id和name判断相等

}

// 3. 初始化并添加元素（Java 9+）

Set<Integer> set = Set.of(1, 2, 3); // 不可变集合

Map<String, Integer> map = Map.of("a", 1, "b", 2); // 不可变映射

// 可变集合的简洁初始化（双括号初始化，谨慎使用，可能有内存泄漏风险）

List<Integer> list = new ArrayList<>() {{ add(1); add(2); }};

2.4 栈（Stack）与双端队列（Deque/ArrayDeque）

虽然Java提供了古老的Stack类，但官方文档推荐使用Deque接口的实现（如ArrayDeque）来模拟栈，因为Stack继承自Vector，是同步的，性能有损耗，且接口设计更老旧。

用ArrayDeque作为栈：

JAVA

Deque<Integer> stack = new ArrayDeque<>();

// 入栈

stack.push(1); // 或 addFirst(e)

stack.offerFirst(2);

// 查看栈顶

int top = stack.peek(); // 或 peekFirst()

// 出栈

int popped = stack.pop(); // 或 removeFirst()

// 判断空

boolean isEmpty = stack.isEmpty();

用ArrayDeque作为队列：

JAVA

Deque<Integer> queue = new ArrayDeque<>();

// 入队（队尾）

queue.offer(1); // 或 addLast(e), offerLast(e)

// 出队（队首）

int head = queue.poll(); // 或 removeFirst(), pollFirst()

// 查看队首

int peek = queue.peek(); // 或 peekFirst()

为什么推荐ArrayDeque？

性能好：基于可扩容数组，大多数操作是O(1)，且比LinkedList（基于链表）有更好的局部性，实际性能通常更高。
功能全：同时完美支持栈和队列的所有操作。
无容量限制（除了系统内存）。

算法题常见应用：

栈：括号匹配、表达式求值、单调栈（解决“下一个更大元素”类问题）、DFS迭代实现。
队列：BFS层序遍历、滑动窗口问题（常与双端队列结合）。

2.5 优先队列PriorityQueue（堆）

PriorityQueue是基于优先级堆（默认为最小堆）的无界队列。它是实现“贪心算法”（如哈夫曼编码、任务调度）和“快速获取极值”场景的核心数据结构。

核心构造与操作：

JAVA

// 1. 默认最小堆（队首是最小元素）

PriorityQueue<Integer> minHeap = new PriorityQueue<>();

minHeap.offer(5);

minHeap.offer(1);

minHeap.offer(3);

System.out.println(minHeap.poll()); // 输出 1

System.out.println(minHeap.poll()); // 输出 3

// 2. 创建最大堆

PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);

// 或者使用 Comparator.reverseOrder()

PriorityQueue<Integer> maxHeap2 = new PriorityQueue<>(Comparator.reverseOrder());

// 3. 自定义对象排序

class Task {

int priority;

String name;

}

PriorityQueue<Task> taskQueue = new PriorityQueue<>((t1, t2) -> t1.priority - t2.priority);

// 核心API

pq.offer(e); // 插入元素，O(log n)

pq.poll(); // 移除并返回队首（极值），O(log n)

pq.peek(); // 查看队首但不移除，O(1)

pq.size();

pq.isEmpty();

算法应用实例：

合并K个有序链表：将每个链表的头节点放入最小堆，每次弹出最小的，将其下一个节点入堆。
数据流的中位数：维护一个最大堆（存较小一半）和一个最小堆（存较大一半）。
Top K 问题：维护一个大小为K的最小堆，遍历所有元素，比堆顶大则替换堆顶，最后堆中即为最大的K个元素。

实操心得： 在需要频繁插入和删除极值的场景，PriorityQueue比先排序再操作要高效得多。但要注意，PriorityQueue的迭代器不保证按优先级顺序遍历。如果需要有序输出所有元素，只能通过反复poll()来实现。

3. 字符串处理与数学工具

字符串和数学运算是算法题的另外两大基础板块，Java标准库提供了丰富的支持。

3.1 字符串String与StringBuilder

String是不可变的，任何修改操作都会产生新对象。在算法题中，频繁拼接字符串时，务必使用StringBuilder（单线程）或StringBuffer（线程安全，但性能稍差）。

String高频API：

charAt(int index)
length()
substring(int beginIndex, int endIndex): 注意，endIndex是 exclusive（不包含的）。s.substring(i, j) 获取的是 s[i...j-1]。
indexOf(String str) / lastIndexOf(String str)
startsWith(String prefix) / endsWith(String suffix)
replace(char oldChar, char newChar) / replaceAll(String regex, String replacement)
split(String regex): 按正则分割，特殊字符如.、|需要转义。
toCharArray(): 转为字符数组进行原地操作，有时更高效。
equals(Object anObject) / equalsIgnoreCase(String anotherString)
compareTo(String anotherString): 字典序比较。

StringBuilder高频API：

append(xxx): 支持各种类型。
insert(int offset, xxx)
delete(int start, int end)
reverse()
charAt(int index)
setCharAt(int index, char ch): 重要，可以原地修改字符。
toString(): 最终生成字符串。

典型用法对比：

JAVA

// 错误示范（在循环中拼接字符串，产生大量中间对象，性能极差）

String result = "";

for (String str : stringList) {

result += str; // 每次循环都 new 一个 StringBuilder，再 toString()

}

// 正确示范

StringBuilder sb = new StringBuilder();

for (String str : stringList) {

sb.append(str);

}

String result = sb.toString();

// 字符串反转

String s = "hello";

String reversed1 = new StringBuilder(s).reverse().toString(); // 方法1

char[] chars = s.toCharArray();

int left = 0, right = chars.length - 1;

while (left < right) {

char temp = chars[left];

chars[left] = chars[right];

chars[right] = temp;

left++;

right--;

}

String reversed2 = new String(chars); // 方法2，原地修改

3.2 数学工具类Math与BigInteger/BigDecimal

java.lang.Math 提供了基本的数学运算，而 java.math.BigInteger 和 BigDecimal 用于处理超出基本数据类型范围的大数和高精度计算。

Math类常用方法：

Math.max(a, b) / Math.min(a, b)
Math.abs(x)
Math.pow(a, b): 返回 a^b，结果是double类型。
Math.sqrt(x): 平方根。
Math.log(x) / Math.log10(x): 自然对数和以10为底的对数。
Math.round(x) / Math.floor(x) / Math.ceil(x): 四舍五入、向下取整、向上取整。
Math.random(): 返回 [0.0, 1.0) 的随机double值。

大数运算（BigInteger）： 当题目涉及的数字可能非常大（比如阶乘、大数相乘），int或long会溢出，必须使用BigInteger。

JAVA

BigInteger a = new BigInteger("12345678901234567890");

BigInteger b = new BigInteger("98765432109876543210");

BigInteger sum = a.add(b);

BigInteger difference = a.subtract(b);

BigInteger product = a.multiply(b);

BigInteger quotient = a.divide(b);

BigInteger remainder = a.mod(b); // 取余

BigInteger gcd = a.gcd(b); // 最大公约数

BigInteger pow = a.pow(100); // 幂运算

int intValue = a.intValue(); // 转为int（可能丢失精度）

long longValue = a.longValue(); // 转为long

String str = a.toString(); // 转为字符串

// 比较

if (a.compareTo(b) > 0) { /* a > b */ }

if (a.equals(BigInteger.ZERO)) { /* a == 0 */ }

高精度计算（BigDecimal）： 用于需要精确小数运算的场景，比如金融计算。

JAVA

BigDecimal d1 = new BigDecimal("0.1");

BigDecimal d2 = new BigDecimal("0.2");

BigDecimal d3 = d1.add(d2); // 0.3，精确！

// 设置精度和舍入模式

BigDecimal result = d1.divide(d2, 10, RoundingMode.HALF_UP);

注意事项： BigInteger和BigDecimal都是不可变对象，每次运算都会返回一个新的对象。对于密集循环中的大数运算，要考虑性能开销。

4. 输入输出（I/O）优化与常用模式

算法题（尤其是在线判题系统）对程序的执行时间和内存有严格限制。低效的I/O可能成为性能瓶颈，特别是当数据量很大时。Java的Scanner虽然易用，但性能较慢。BufferedReader + StringTokenizer 或 String.split() 是更快的选择。

4.1 快速输入模板

对于需要读取大量整数、字符串的题目，建议使用以下模板：

JAVA

import java.io.*;

import java.util.*;

public class Main {

public static void main(String[] args) throws IOException {

// 方案1：使用 BufferedReader 和 StringTokenizer (最快)

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

StringTokenizer st = new StringTokenizer(br.readLine());

int n = Integer.parseInt(st.nextToken()); // 读取第一个整数

int m = Integer.parseInt(st.nextToken()); // 读取第二个整数

// 读取一行字符串

String line = br.readLine();

// 读取整个数字数组（假设一行内）

int[] arr = new int[n];

st = new StringTokenizer(br.readLine());

for (int i = 0; i < n; i++) {

arr[i] = Integer.parseInt(st.nextToken());

}

// 方案2：使用 BufferedReader 和 split (也很快，更直观)

String[] parts = br.readLine().split(" ");

int a = Integer.parseInt(parts[0]);

int b = Integer.parseInt(parts[1]);

// 方案3：使用 Stream API (Java 8+, 简洁但稍慢)

int[] arr2 = Arrays.stream(br.readLine().split(" "))

.mapToInt(Integer::parseInt)

.toArray();

br.close();

}

4.2 快速输出模板

当需要输出大量内容时，使用StringBuilder收集结果一次性输出，或者使用BufferedWriter，比多次调用System.out.print快得多。

JAVA

import java.io.*;

public class Main {

public static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(...);

// 方法1：使用 StringBuilder

StringBuilder sb = new StringBuilder();

for (int i = 0; i < 100000; i++) {

sb.append(i).append(" ");

}

System.out.println(sb.toString()); // 一次性输出

// 方法2：使用 BufferedWriter (最快)

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

for (int i = 0; i < 100000; i++) {

bw.write(i + " ");

}

bw.newLine(); // 换行

bw.flush(); // 重要！确保数据写出

bw.close();

}

4.3 文件I/O（如果题目要求）

有些本地调试或特定题目需要文件读写。

JAVA

// 从文件读取

BufferedReader fileBr = new BufferedReader(new FileReader("input.txt"));

String line = fileBr.readLine();

fileBr.close();

// 写入文件

BufferedWriter fileBw = new BufferedWriter(new FileWriter("output.txt"));

fileBw.write("结果");

fileBw.newLine();

fileBw.close();

实操心得： 在参加在线笔试（如牛客、赛码）时，务必确认输入输出是标准控制台（System.in/out）还是文件。使用BufferedReader和BufferedWriter的组合几乎总是最优解。记得在程序最后调用flush()和close()，或者对于标准输出，至少调用一次flush()确保所有缓冲数据被写出。

5. 实用工具类与技巧合集

除了上述大类，还有一些散落但极其有用的工具类和方法，能让你在解题时代码更简洁、思路更清晰。

5.1 Collections工具类

java.util.Collections 提供了大量操作集合的静态方法。

Collections.sort(list): 对List排序，等同于list.sort(null)。
Collections.reverse(list): 反转列表。
Collections.shuffle(list): 随机打乱列表。
Collections.binarySearch(list, key): 二分查找。
Collections.max(collection) / Collections.min(collection): 查找最大/最小元素。
Collections.frequency(collection, o): 返回指定元素出现次数。
Collections.fill(list, obj): 用指定元素填充列表。
Collections.swap(list, i, j): 交换列表中两个位置的元素。非常实用！
Collections.unmodifiableList(list): 返回一个不可修改的视图。

5.2 数组与集合的互转

JAVA

// List 转数组

List<String> list = Arrays.asList("a", "b", "c");

String[] array1 = list.toArray(new String[0]); // 推荐，参数指定类型

String[] array2 = list.toArray(new String[list.size()]);

// 数组转 List (可变的)

String[] arr = {"a", "b", "c"};

List<String> list1 = new ArrayList<>(Arrays.asList(arr)); // 可变

List<String> list2 = Arrays.asList(arr); // 固定大小，不可变结构

// 使用 Stream (Java 8+)

List<Integer> intList = Arrays.stream(intArr).boxed().collect(Collectors.toList());

int[] intArr2 = intList.stream().mapToInt(i -> i).toArray();

5.3 位运算与包装类方法

位运算在状态压缩、权限判断等题目中非常高效。

JAVA

// 常用位操作

int x = 5; // 0101

int y = 3; // 0011

int and = x & y; // 0001 (1)

int or = x | y; // 0111 (7)

int xor = x ^ y; // 0110 (6)

int not = ~x; // 取反

int leftShift = x << 1; // 1010 (10) 相当于 *2

int rightShift = x >> 1; // 0010 (2) 有符号右移，相当于 /2

int unsignedRightShift = x >>> 1; // 无符号右移

// 判断奇偶

boolean isOdd = (x & 1) == 1;

// 判断是否是2的幂

boolean isPowerOfTwo = x > 0 && (x & (x - 1)) == 0;

// 获取最低位的1

int lowbit = x & -x;

包装类（如Integer, Character）的静态方法也很好用：

JAVA

// Integer

int max = Integer.MAX_VALUE;

int min = Integer.MIN_VALUE;

String binaryStr = Integer.toBinaryString(10); // "1010"

String hexStr = Integer.toHexString(255); // "ff"

int parsed = Integer.parseInt("123"); // 可能抛出NumberFormatException

int parsedSafe = Integer.parseInt("123", 10); // 指定基数

// Character

boolean isDigit = Character.isDigit('9');

boolean isLetter = Character.isLetter('a');

boolean isUpperCase = Character.isUpperCase('A');

char lower = Character.toLowerCase('B'); // 'b'

5.4 日期与随机数（偶尔用到）

JAVA

// 随机数 (用于生成测试数据或随机化算法)

Random rand = new Random();

int randomNum = rand.nextInt(100); // [0, 100)

double randomDouble = rand.nextDouble(); // [0.0, 1.0)

// 日期 (极少在算法题用到，了解即可)

LocalDate date = LocalDate.now();

LocalDateTime dateTime = LocalDateTime.now();

6. 算法题实战：API选择与性能考量

掌握了这么多API，关键是要在正确的场景下使用。这里结合具体算法思想，谈谈API的选择策略。

6.1 搜索与排序场景

快速查找元素是否存在：首选HashSet（O(1)），如果数据范围小且是整数，可以考虑boolean[]标记数组。
需要维护元素顺序的快速查找：TreeSet（基于红黑树，O(log n) 查找、插入、删除），支持ceiling(e)（大于等于e的最小元素）、floor(e)等有序操作。
对数组或列表排序：Arrays.sort() 或 Collections.sort()。如果需要非递减（允许相等）排序，使用默认比较器或Comparator.naturalOrder()；如果需要非递增，使用Comparator.reverseOrder()。
只关心最大/最小的K个元素：使用PriorityQueue（堆），而不是全部排序。维护一个大小为K的堆，时间复杂度为O(n log K)，优于O(n log n)。

6.2 图与树遍历场景

BFS（广度优先搜索）：使用Queue接口，实现类用ArrayDeque。

JAVA

Queue<TreeNode> queue = new ArrayDeque<>();

queue.offer(root);

while (!queue.isEmpty()) {

int levelSize = queue.size();

for (int i = 0; i < levelSize; i++) {

TreeNode node = queue.poll();

// 处理 node

if (node.left != null) queue.offer(node.left);

if (node.right != null) queue.offer(node.right);

}

}
DFS（深度优先搜索）递归：利用系统调用栈，代码简洁。
DFS迭代：使用Stack，但推荐用ArrayDeque模拟。

JAVA

Deque<TreeNode> stack = new ArrayDeque<>();

stack.push(root);

while (!stack.isEmpty()) {

TreeNode node = stack.pop();

// 处理 node

if (node.right != null) stack.push(node.right); // 注意入栈顺序

if (node.left != null) stack.push(node.left);

}

6.3 动态规划与状态记录

记忆化搜索（Memoization）：使用HashMap或数组来存储子问题的解。键的设计很重要，通常是参数组合。

JAVA

Map<String, Integer> memo = new HashMap<>();

int helper(String s, int index) {

String key = index + "#" + s.substring(index); // 构造唯一键

if (memo.containsKey(key)) return memo.get(key);

// ... 计算逻辑

memo.put(key, result);

return result;

}
DP表：通常使用二维或多维数组int[][] dp。如果状态只与前一两个状态相关，可以用滚动数组优化空间，例如用两个一维数组交替使用。

6.4 字符串匹配与处理

简单匹配：String的contains(), indexOf()。
正则表达式匹配：String的matches(regex)，但性能一般，复杂场景慎用。
分割字符串：String.split(regex)，注意正则转义。
可变字符串操作：一律用StringBuilder。
字符统计：如果字符集是ASCII或有限的，使用int[26]或int[128]数组作为计数器，比HashMap<Character, Integer>更快。

JAVA

String s = "leetcode";

int[] count = new int[26];

for (char c : s.toCharArray()) {

count[c - 'a']++;

}

6.5 性能陷阱与优化建议

避免在循环中创建对象：比如在循环内部new StringBuilder()或new StringTokenizer()，应尽量复用。
选择合适的数据结构：LinkedList在中间频繁插入删除时表现好，但随机访问慢。ArrayList随机访问快，但中间插入删除慢。ArrayDeque在作为栈/队列时通常比LinkedList快。
注意自动装箱/拆箱开销：在性能关键的循环中，使用基本类型数组（int[]）而非包装类集合（List<Integer>）。
使用StringBuilder的setLength(0)来清空，而不是new StringBuilder()，可以复用底层字符数组。
优先使用Arrays.fill()和System.arraycopy() 进行数组填充和拷贝，它们通常是原生方法，速度更快。
在线判题时关闭调试输出：大量的System.out.println会极大拖慢速度，提交前确保移除或使用高效的输出方式。

这份总结几乎涵盖了Java算法题中90%以上你会用到的核心API和技巧。最好的掌握方法不是死记硬背，而是在刷题过程中有意识地去运用和回顾。建议你将它保存下来，遇到不确定的语法或想寻找更优解时，快速查阅对应的章节。随着练习的增多，这些API会逐渐内化成你的肌肉记忆，让你在解题时更加游刃有余。