字节 Data 全栈岗 · 刷题手册

配套：《字节Data北京全栈岗面试准备》（SQL 题、前四道算法、后端八股）。本手册收录新面经里的题目，以及同类型、同难度的高频题。 所有代码都用 Java 实际运行过，结果正确。 招聘方的提醒：可能不考原题，但类型和难度差不多。一定要写出来，不能只说思路。

0. 怎么保证“写得出来”

0.1 从这几份面经看面试官怎么打分

面经里给候选人打的是四个维度：思维沟通、项目经验、基础知识、编程能力。通过的那位，编程能力的评价是“算法题能写出来，思路也可以”。写出来是底线，思路好是加分。

0.2 硬写的策略（卡住时照这个顺序走）

1. 先确认题意和边界（30 秒）：输入为空怎么办？n 超出长度怎么办？
2. 先写能跑的版本：想不出最优解，就先写一个暴力解法，比如链表题先把值放进数组再处理。能跑的暴力解法远远好过一个没写完的最优解。写完再说“我再优化一下”。
3. 链表题一律用虚拟头节点：ListNode dummy = new ListNode(0); dummy.next = head; 能消掉“删除的是头节点”这类特殊情况，大部分链表题都能少写一半判断。
4. 边写边说：每写一段就说这段在干什么，面试官能跟上你的思路，卡住时也更愿意提示。
5. 写完马上用题目给的例子手动走一遍，然后主动说复杂度和边界。

0.3 练习方法（这是关键）

看懂答案不等于会写。每道题都按这个流程练： 1. 先自己想 10 分钟，写不出就看答案； 2. 看懂后合上答案，在白纸或纯文本编辑器里从头默写，不开代码补全、不用 AI； 3. 写错了再看一眼，再合上重写，直到一次写对； 4. 第二天再默写一遍，还能一次写对才算掌握。

1. 链表题（这个岗位最爱考，6 道里占了 4 道）

1.1 删除链表的倒数第 n 个节点

思路：快慢指针。快指针先走 n 步，然后两个指针一起走；快指针走到最后一个节点时，慢指针正好停在要删除节点的前一个。用虚拟头节点处理“删除的是头节点”的情况。

复杂度：一次遍历，时间 O(L)，空间 O(1)。

public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0);   // 虚拟头节点：删除头节点时不用特殊处理
    dummy.next = head;
    ListNode fast = dummy, slow = dummy;
    for (int i = 0; i < n; i++) {       // 快指针先走 n 步
        if (fast.next == null) throw new IllegalArgumentException("n 大于链表长度");
        fast = fast.next;
    }
    while (fast.next != null) {         // 一起走，直到快指针到最后一个节点
        fast = fast.next;
        slow = slow.next;
    }
    slow.next = slow.next.next;         // 慢指针的下一个就是要删的节点
    return dummy.next;                  // 不能返回 head：head 可能已经被删掉了
}

已验证：[1,2,3,4,5] 删倒数第 2 个得 [1,2,3,5]；[1] 删倒数第 1 个得 []；[1,2] 删倒数第 1 个得 [1]；[1,2] 删倒数第 2 个得 [2]（删的是头节点）。

易错点：返回值要用 dummy.next，不能用 head，因为头节点可能被删了。

1.2 删除链表的正数第 n 个节点

思路：用虚拟头节点，走到第 n−1 个节点（要删节点的前一个），把它的 next 跳过一个。

public ListNode removeNth(ListNode head, int n) {
    if (n <= 0) throw new IllegalArgumentException("n 必须大于 0");
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode prev = dummy;
    for (int i = 1; i < n; i++) {          // 走到第 n-1 个节点
        if (prev.next == null) throw new IllegalArgumentException("n 大于链表长度");
        prev = prev.next;
    }
    if (prev.next == null) throw new IllegalArgumentException("n 大于链表长度");
    prev.next = prev.next.next;            // 跳过第 n 个节点
    return dummy.next;
}

已验证：1→3→4→8 删第 2 个得 1→4→8；删第 1 个得 3→4→8；删第 4 个得 1→3→4；n 越界会报错。

1.3 K 个一组翻转链表（这批题里最难的一道，重点练）

思路：每次先往后数 k 个节点，不够 k 个就停止（剩下的保持原样）；够 k 个就把这一段原地反转，再接回原链表。

需要记住四个指针： - groupPrev：这一组的前一个节点（第一组就是虚拟头节点） - kth：这一组的第 k 个节点（反转后它变成这一组的头） - groupNext：下一组的第一个节点 - 反转时把 prev 初始化为 groupNext，反转完这一组的尾巴自然就接上了下一组

public ListNode reverseKGroup(ListNode head, int k) {
    if (head == null || k <= 1) return head;
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode groupPrev = dummy;                 // 当前组的前一个节点
    while (true) {
        // 1. 找到当前组的第 k 个节点，不够 k 个就结束
        ListNode kth = groupPrev;
        for (int i = 0; i < k && kth != null; i++) kth = kth.next;
        if (kth == null) break;
        ListNode groupNext = kth.next;          // 下一组的第一个节点

        // 2. 反转当前组。prev 从 groupNext 开始，反转后组尾直接连上下一组
        ListNode prev = groupNext, cur = groupPrev.next;
        while (cur != groupNext) {
            ListNode next = cur.next;
            cur.next = prev;
            prev = cur;
            cur = next;
        }

        // 3. 接回原链表：原来的第一个节点现在是组尾，作为下一组的 groupPrev
        ListNode oldFirst = groupPrev.next;
        groupPrev.next = kth;                   // 组头变成原来的第 k 个
        groupPrev = oldFirst;
    }
    return dummy.next;
}

已验证：[1,2,3,4,5] k=2 得 [2,1,4,3,5]；k=3 得 [3,2,1,4,5]；k=1 不变；[1,2,3,4] k=4 得 [4,3,2,1]；[1,2,3,4,5,6] k=3 得 [3,2,1,6,5,4]。

画图讲解（面试时边画边讲）：以 1→2→3→4→5、k=2 为例。第一组：groupPrev 是虚拟头，kth 是 2，groupNext 是 3。反转后是 2→1→3，虚拟头指向 2，groupPrev 移到 1。第二组同理得到 4→3→5。第三组只剩 5，不够 2 个，停止。

复杂度：每个节点被访问常数次，时间 O(n)，空间 O(1)。

如果实在写不出来的保底方案：把整个链表的值读进数组，每 k 个一段在数组里反转，再写回链表。但题目要求不能只改值、必须交换节点，所以这只能作为“先写个能跑的版本”，写完要说明“这个版本改的是值，题目要求交换节点，我再改成原地反转”。

1.4 回文链表

思路： - 简单解法：把值放进数组，用双指针从两头往中间比较。时间 O(n)，空间 O(n)。先写这个保底。 - 最优解（空间 O(1)，加分）：①快慢指针找中点；②反转后半段；③前半段和反转后的后半段逐个比较；④把后半段再反转回来，恢复原链表。

public boolean isPalindrome(ListNode head) {
    if (head == null || head.next == null) return true;
    // 1. 找中点：快指针每次两步，慢指针每次一步；结束时 slow 停在前半段的最后一个节点
    ListNode slow = head, fast = head;
    while (fast.next != null && fast.next.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    // 2. 反转后半段
    ListNode secondHead = reverse(slow.next);
    // 3. 比较。以后半段为准：奇数长度时中间节点归前半段，不参与比较
    ListNode p1 = head, p2 = secondHead;
    boolean ok = true;
    while (p2 != null) {
        if (p1.val != p2.val) { ok = false; break; }
        p1 = p1.next;
        p2 = p2.next;
    }
    // 4. 恢复原链表（加分点：不破坏调用方的数据）
    slow.next = reverse(secondHead);
    return ok;
}

private ListNode reverse(ListNode head) {
    ListNode prev = null, cur = head;
    while (cur != null) {
        ListNode next = cur.next;
        cur.next = prev;
        prev = cur;
        cur = next;
    }
    return prev;
}

已验证：[1,2,2,1] 为 true，而且判断完链表恢复成 [1,2,2,1]；[1,2] 为 false；[1,2,3,2,1] 为 true；单个节点和空链表为 true；[1,2,3] 为 false。

隐藏考点：奇数长度的中间节点怎么处理；判断完要恢复链表；多线程同时读这个链表时，临时修改会有问题，这种情况就用数组解法。

2. 字符串、栈、哈希

2.1 有效的括号

思路：用栈。遇到左括号，就把对应的右括号压栈；遇到右括号，就弹出栈顶比较，不一样或者栈是空的就返回 false。最后栈必须为空。

public boolean isValid(String s) {
    if (s == null || s.length() % 2 == 1) return false;  // 长度为奇数一定无效，提前返回
    Deque<Character> stack = new ArrayDeque<>();          // 用 ArrayDeque，不用过时的 Stack 类
    for (char c : s.toCharArray()) {
        if (c == '(') stack.push(')');                    // 压入期望出现的右括号，比较时更简单
        else if (c == '[') stack.push(']');
        else if (c == '{') stack.push('}');
        else if (stack.isEmpty() || stack.pop() != c) return false;
    }
    return stack.isEmpty();                               // 还有没闭合的左括号也是无效
}

已验证：()、()[]{}、([])、{[]} 为 true；(]、([)]、(、)( 为 false。

复杂度：时间 O(n)，空间 O(n)。

隐藏考点：右括号多出来时栈是空的，要先判断再弹出；最后要检查栈为空；长度为奇数可以提前返回；Java 里推荐用 ArrayDeque 而不是 Stack（Stack 是同步的，性能差）。

2.2 最长公共前缀

思路：纵向扫描。以第一个字符串为基准，逐个位置检查所有字符串在这个位置的字符是否相同；某个字符串到头了或者字符不同，就返回到当前位置为止的前缀。

public String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0) return "";
    String first = strs[0];
    for (int i = 0; i < first.length(); i++) {
        char c = first.charAt(i);
        for (int j = 1; j < strs.length; j++) {
            // 其他字符串到头了，或者这个位置的字符不同
            if (i >= strs[j].length() || strs[j].charAt(i) != c) {
                return first.substring(0, i);
            }
        }
    }
    return first;   // 第一个字符串整体就是公共前缀
}

已验证：[“flower”,“flow”,“flight”] 得 “fl”；[“dog”,“racecar”,“car”] 得 "“；只有一个字符串时返回它本身；含空字符串时返回”“；["abc","abcd"] 得”abc"。

复杂度：时间 O(所有字符串的字符总数)，最坏情况每个字符都比较一次；空间 O(1)。

追问：「另一种思路？」把字符串排序后，只需要比较第一个和最后一个字符串的公共前缀（字典序最远的两个）。但排序是 O(n log n)，不一定更快。

2.3 无重复字符的最长子串

见《全栈岗面试准备》§3.4，这里给数组版本（字符都在 ASCII 范围内时更快）：

public int lengthOfLongestSubstring(String s) {
    int[] last = new int[128];       // 每个字符最后一次出现的位置
    Arrays.fill(last, -1);
    int left = 0, best = 0;
    for (int right = 0; right < s.length(); right++) {
        char c = s.charAt(right);
        if (last[c] >= left) left = last[c] + 1;  // 重复字符在窗口内，左边界跳过它
        last[c] = right;
        best = Math.max(best, right - left + 1);
    }
    return best;
}

已验证：abcabcbb 为 3，bbbbb 为 1，abba 为 2，空字符串为 0。

3. SQL：查找重复的电子邮箱

SELECT email AS Email
FROM Person
WHERE email IS NOT NULL       -- 空值不算重复
GROUP BY email
HAVING COUNT(*) > 1;

另一种写法（自连接，面试官可能让你写第二种）：

SELECT DISTINCT p1.email AS Email
FROM Person p1
JOIN Person p2 ON p1.email = p2.email AND p1.id <> p2.id;

两种写法的对比：GROUP BY 只扫一遍表，效率高，推荐；自连接在数据量大时开销大，但思路直观。

隐藏考点（实测发现的，主动讲加分）： 1. 空值：GROUP BY 会把所有空邮箱归为一组，如果有两条空邮箱，结果里会出现一个空值，所以要加 WHERE email IS NOT NULL。 2. 大小写和空格：MySQL 常用的排序规则默认不区分大小写，A@b.com 和 a@b.com 会被当成同一个邮箱；业务上如果要区分，就要注意排序规则；反过来，如果要把前后带空格的也算重复，可以用 LOWER(TRIM(email)) 分组。 3. 追问「删除重复的邮箱，只保留 id 最小的一条」：

DELETE p1 FROM Person p1
JOIN Person p2 ON p1.email = p2.email AND p1.id > p2.id;

4. 同类型高频题（有余力再练，按优先级）

5. 面经里新出现的八股题（简洁答法）

MySQL

• MySQL 和 ES 的区别：MySQL 是关系型数据库，支持事务，B+ 树索引，适合精确查询和事务操作；ES 是搜索引擎，用倒排索引，擅长全文检索、分词和复杂条件过滤，近实时（写入后默认约 1 秒可查），不支持事务。常见组合：MySQL 存主数据，通过监听 binlog 同步到 ES 做搜索。
• undo log 和 redo log：undo log 记录修改前的数据，用于事务回滚和 MVCC 读历史版本；redo log 记录修改后的数据页变化，先写日志再写数据（WAL），保证事务的持久性和崩溃恢复。再加一个 binlog：MySQL 服务层的日志，用于主从复制和数据恢复。
• 避免死锁：所有事务按固定顺序访问资源；事务尽量小、尽量短；设置锁等待超时；用合适的索引，减少锁住的范围。
• 默认隔离级别：可重复读（RR）。

Redis

• 数据类型：五种基础类型：字符串、哈希、列表、集合、有序集合；扩展类型：位图（bitmap）、HyperLogLog（基数统计）、地理位置（geo）、Stream（消息流）。
• 有序集合（zset）怎么实现（面经里有人答错）：元素少时用紧凑的列表结构（ziplist，新版本是 listpack）；元素多时用跳表加哈希表。跳表负责按分数排序和范围查询（多层索引，查找平均 O(log n)）；哈希表负责按成员 O(1) 查分数。
• 为什么快：数据在内存里；命令执行是单线程，没有锁和线程切换；用 IO 多路复用同时处理大量连接；数据结构高效。Redis 6 以后网络读写可以用多线程，命令执行仍然是单线程。
• select、poll、epoll 的区别：select 用固定大小的数组（默认最多 1024 个连接），每次调用都要把整个集合从用户态复制到内核态，并遍历全部连接；poll 用链表，去掉了数量上限，但仍要遍历；epoll 在内核里维护关注的连接，只返回有事件就绪的连接，不用每次遍历全部，连接数多时效率高得多。
• 高可用部署：主从复制；哨兵模式（自动故障转移，主节点挂了选出新主）；集群模式（数据分片到多个主节点，每个主节点带从节点）。

消息队列

• 核心组件：Kafka 是生产者、消费者、主题、分区、Broker、消费者组；RabbitMQ 还有交换机，负责按规则把消息路由到不同队列。
• Kafka 为什么性能高：顺序写磁盘；利用操作系统页缓存；零拷贝（数据直接从页缓存发到网卡，不经过用户态）；批量发送和压缩；分区并行读写。（面经里有人答“内存、增量拉取”，不够完整。）
• 保证数据库操作和发消息的原子性：本地消息表：在同一个本地事务里，既写业务数据，也写一条“待发送消息”记录；再由后台任务把消息发出去，发送成功后改状态，失败了重试。消费端做幂等。也可以用 RocketMQ 的事务消息。
• 分布式事务：两阶段提交（强一致，性能差）；TCC（每个操作都写好尝试、确认、取消三个步骤）；Saga（长流程，失败时执行补偿操作）；阿里的 Seata 框架支持这几种模式。实际业务里更多用“本地消息表加最终一致”。

网络

• cookie 和 session：cookie 存在浏览器，有大小限制，可能被篡改，安全性低；session 存在服务端，更安全，但占服务端内存，多台机器时要共享（比如存到 Redis）。常见做法：session ID 存在 cookie 里，每次请求带上，服务端用它找到 session。
• JWT：把用户信息加上签名做成令牌，服务端不用存会话，适合分布式；缺点是签发后在过期前很难主动作废。
• HTTP 和 HTTPS：HTTPS 在 HTTP 下面加了 TLS 加密层，默认端口 443（HTTP 是 80）；靠证书验证服务器身份，防止被窃听和篡改。握手时用非对称加密交换密钥，之后用对称加密传数据。
• TCP 怎么保证可靠（面经里有人把握手次数说反了）：三次握手建立连接、四次挥手断开连接；序列号加确认应答；超时重传；滑动窗口做流量控制；拥塞控制（慢启动、拥塞避免、快重传、快恢复）；校验和。

Java 和 Spring

• Spring 用到的设计模式：工厂（BeanFactory 创建对象）、单例（Bean 默认是单例）、代理（AOP）、模板方法（JdbcTemplate、RestTemplate）、观察者（事件监听机制）、适配器（Spring MVC 的 HandlerAdapter）。
• ConcurrentHashMap 的实现：JDK 8 以后，结构是数组加链表或红黑树（和 HashMap 一样）；桶为空时用 CAS 放入，不为空时只锁这个桶的头节点（synchronized），锁粒度很小；扩容时多个线程可以协助迁移数据；size 用分段计数，减少竞争。JDK 7 是分段锁（Segment）。
• CAP 定理：一致性、可用性、分区容错性。网络分区不可避免，所以实际上是在一致性和可用性之间选：选 CP（比如 ZooKeeper），选 AP（比如 Eureka）。

工具

• Linux 常用命令：top（CPU 和内存）、free -h（内存）、df -h（磁盘）、tail -f（实时看日志）、grep、less、ps -ef、netstat 或 ss（端口和连接）、jstack、jmap（Java 排查）。
• git merge 和 rebase：merge 保留完整的分支历史，会多一个合并提交；rebase 把自己的提交“搬到”目标分支最新提交之后，历史是一条直线，更干净。原则：已经推送、别人也在用的公共分支不要 rebase。

其他

• 如何学一门新语言（Go）： > “先过一遍核心语法和特性，重点看它和我熟悉的 Java 不一样的地方，比如 goroutine 和 channel、接口隐式实现、错误处理方式；然后读团队现有的项目代码，照着写小功能；遇到问题查官方文档和标准库源码。我估计一两周能上手写业务代码。”
• 换工作原因：用实话，一句话：家里老人生病，主动离职照顾，现在已经安排好了。
• AI 怎么用：面经里通过的候选人说“写单元测试、存储过程，日常提效 30%”。你可以说：“我用 AI 写单元测试、生成样板代码、辅助排查问题，核心逻辑和代码 review 自己把关。”不要说“主要靠 AI 写代码”。

项目题提醒

面经里通过的候选人讲了一个很典型的接口性能调优故事：数据大盘接口 7 到 8 秒，用 Arthas 定位到慢 SQL，用 EXPLAIN 分析后优化索引、冗余字段，再加 Redis 缓存。这种故事面试官很爱听。请从你自己的经历里找一个真实的性能优化案例（比如美团查询接口的限流和批量查询、阿里的某个慢查询），按“现象 → 定位工具 → 原因 → 方案 → 效果”整理好。一定要用真实经历，不要照搬别人的。

6. 练习计划（到面试前）

最后一句：面试时不管多紧张，先写出一个能跑的版本。写出来了，哪怕不是最优解也能及格；只讲思路，就是零分。