Coding Interview University：软件工程师求职学习指南

学习目标

阅读本文后，您将能够：

• ✅ 理解 Coding Interview University 的核心理念与学习方法
• ✅ 掌握完整的学习路线图（从基础到进阶）
• ✅ 熟悉数据结构和算法的核心知识点
• ✅ 了解推荐的学习资源和面试书籍
• ✅ 制定个人化的每日学习计划
• ✅ 准备一份优秀的简历和面试技巧

一、项目概述

1.1 什么是 Coding Interview University

Coding Interview University（简称 CIU）是由 jwasham 创建的多月度软件工程师学习计划。创始人最初只是想准备 Google 面试而整理了一份学习清单，后来这份清单不断扩充，最终成为 GitHub 上最受欢迎的面试准备指南之一。

创始人通过这个计划成功入职 Amazon，并在 Medium 上分享了自己的故事：
“Why I studied full-time for 8 months for a Google interview”

重要说明： 你不需要像创始人一样学习 8-12 小时/天。大多数人不需要那么长时间，关键是高效学习，而不是堆砌时间。

1.2 关键数据

1.3 项目定位

CIU 不是要教你所有计算机科学知识，而是聚焦于通过技术面试所需的核心知识点：

• ✅ 面试所需的算法和数据结构知识（约75%的CS知识）
• ✅ 编程题练习方法和资源
• ✅ 简历和面试技巧
• ❌ 不是前端/全栈开发路线图（另有 roadmap.sh）

1.4 为什么选择 CIU

创始人背景：

• 非科班出身，自学编程
• 学习前：不知道 stack 和 heap 的区别，不懂 Big-O，不了解树和图的遍历
• 学习后：入职 Amazon 软件开发工程师岗位

CIU 能给你：

• 结构化的学习路径（不需要自己摸索）
• 精选的学习资源（不需要大海捞针）
• 可量化的进度跟踪（GitHub Markdown 任务列表）
• 社区支持（多语言翻译、众多 Fork）

二、学习路线图详解

2.1 学习阶段总览

CIU 将学习分为三大阶段：

┌─────────────────────────────────────────────────────────────┐
│                    Coding Interview University               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  第一阶段：编程基础    ─────►  第二阶段：核心知识  ─────►  第三阶段：求职准备 │
│  (2-4周)                          (3-4个月)                    (2-4周)            │
│                                                             │
│  • 选择编程语言            • 数据结构                      • 简历优化         │
│  • 算法复杂度             • 排序算法                      • 面试技巧         │
│  • 基本数据类型           • 图论基础                      • 题库练习         │
│                              • 动态规划                    • 系统设计         │
│                              • 递归                      • 行为面试         │
└─────────────────────────────────────────────────────────────┘

2.2 第一阶段：编程基础（2-4周）

前置要求：

• 有编程基础（变量、循环、函数等概念）
• 耐心
• 时间投入

学习内容：

为什么推荐 C 语言？

C 语言非常底层，能让你深入理解指针和内存管理。当你学习数据结构时，能够"感受"到数据结构的本质。在高级语言中这些是隐藏的，但理解底层实现对学习非常有帮助。

2.3 第二阶段：核心知识（3-4个月）

这是 CIU 的核心部分，涵盖面试所需的所有技术知识点：

数据结构

核心算法

排序算法：

• 选择排序（Selection Sort）
• 插入排序（Insertion Sort）
• 堆排序（Heap Sort）
• 快速排序（Quick Sort）
• 归并排序（Merge Sort）

图算法：

• 广度优先搜索（BFS）
• 深度优先搜索（DFS）
• Dijkstra 算法
• Bellman-Ford 算法
• Floyd-Warshall 算法

高级主题：

• 递归（Recursion）
• 动态规划（Dynamic Programming）
• 回溯算法（Backtracking）
• 分治算法（Divide and Conquer）

2.4 第三阶段：求职准备（2-4周）

简历优化：

• 突出项目经验
• 量化成果（“性能提升 50%"）
• GitHub 和技术博客

面试技巧：

• 行为面试（STAR 方法）
• 技术面试流程
• 向面试官提问

三、数据结构深度解析

3.1 数组（Arrays）

基本概念：

• 连续内存空间
• 随机访问：O(1)
• 插入/删除：O(n)

面试常见问题：

# 两数之和
def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

3.2 链表（Linked Lists）

单向链表节点结构：

struct ListNode {
    int val;
    struct ListNode *next;
};

核心操作复杂度：

必刷题目：

1. 反转链表
2. 检测链表环
3. 合并两个有序链表
4. 删除倒数第 N 个节点

3.3 栈和队列（Stack & Queue）

栈（LIFO）：

# Python 实现栈
stack = []
stack.append(1)  # push
stack.pop()       # pop

队列（FIFO）：

from collections import deque
queue = deque()
queue.append(1)  # enqueue
queue.popleft()   # dequeue

应用场景：

• 栈：函数调用栈、括号匹配、表达式求值
• 队列：任务调度、BFS、消息队列

3.4 哈希表（Hash Table）

核心原理：

• 哈希函数：将键映射到数组索引
• 冲突处理：链地址法（Chaining）或开放地址法（Open Addressing）

复杂度：

3.5 树（Trees）

二叉树遍历：

# 前序遍历（根-左-右）
def preorder(root):
    if root:
        print(root.val)
        preorder(root.left)
        preorder(root.right)

# 中序遍历（左-根-右）
def inorder(root):
    if root:
        inorder(root.left)
        print(root.val)
        inorder(root.right)

# 后序遍历（左-右-根）
def postorder(root):
    if root:
        postorder(root.left)
        postorder(root.right)
        print(root.val)

二叉搜索树（BST）：

• 左子树所有节点 < 根节点 < 右子树所有节点
• 搜索、插入、删除：平均 O(log n)

3.6 堆（Heap）

最大堆性质：

• 父节点 >= 子节点
• 完全二叉树
• 用数组实现

核心操作：

应用：

• 优先队列
• Top K 问题
• 中位数问题

3.7 图（Graphs）

表示方法：

# 邻接表
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D'],
    'C': ['A', 'D'],
    'D': ['B', 'C']
}

# 邻接矩阵
# [[0, 1, 1, 0],
#  [1, 0, 0, 1],
#  [1, 0, 0, 1],
#  [0, 1, 1, 0]]

BFS 模板：

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    visited.add(start)
    
    while queue:
        node = queue.popleft()
        print(node)
        
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

四、算法思想深度解析

4.1 递归（Recursion）

递归三要素：

1. 基线条件（Base Case）：停止递归的条件
2. 递归条件（Recursive Case）：调用自身
3. 收敛性：每次调用都向基线条件靠近

经典问题：

# 斐波那契数列
def fib(n):
    if n <= 1:          # 基线条件
        return n
    return fib(n-1) + fib(n-2)  # 递归条件

# 阶乘
def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1)

4.2 动态规划（Dynamic Programming）

DP 适用条件：

1. 最优子结构（Optimal Substructure）
2. 重叠子问题（Overlapping Subproblems）

解题步骤：

1. 定义子问题
2. 猜测递推关系
3. 建立 DP 表
4. 证明正确性

经典例题：

# 爬楼梯问题
def climb_stairs(n):
    if n <= 2:
        return n
    dp = [0] * (n + 1)
    dp[1] = 1
    dp[2] = 2
    for i in range(3, n + 1):
        dp[i] = dp[i-1] + dp[i-2]
    return dp[n]

# 优化空间复杂度
def climb_stairs_optimized(n):
    if n <= 2:
        return n
    prev, curr = 1, 2
    for _ in range(3, n + 1):
        prev, curr = curr, prev + curr
    return curr

4.3 回溯算法（Backtracking）

模板：

def backtrack(path, choices):
    if is_goal(path):
        result.append(path.copy())
        return
    
    for choice in choices:
        if is_valid(path, choice):
            path.append(choice)
            backtrack(path, new_choices(path, choice))
            path.pop()

经典问题：

• N 皇后问题
• 全排列
• 子集和问题

4.4 分治算法（Divide and Conquer）

模板：

def divide_and_conquer(problem):
    if is_small(problem):
        return solve_small(problem)
    
    # 分
    subproblems = split(problem)
    
    # 治
    subresults = [divide_and_conquer(sp) for sp in subproblems]
    
    # 合
    return combine(subresults)

经典应用：

• 归并排序：O(n log n)
• 快速排序：平均 O(n log n)
• 二分查找：O(log n)

五、推荐学习资源

5.1 算法和数据结构书籍

Python 推荐

C 语言推荐

Java 推荐

5.2 面试准备书籍

5.3 在线学习平台

5.4 视频资源

六、学习方法论

6.1 每日学习计划

创始人建议的学习节奏：

• 每天学习 8-12 小时
• 持续数月
• 周末不休息

普通人可行的计划：

## 每日计划模板

| 时段 | 内容 | 时长 |
|------|------|------|
| 早上 | 学习新知识点（看视频/看书） | 1-2h |
| 上午 | 编码实现 + 做笔记 | 2h |
| 下午 | 做练习题 | 2-3h |
| 晚上 | 复习 + 刷题 | 1-2h |

每周至少学习 5 天

6.2 刷题策略

三遍刷题法：

第一遍（理解）：

1. 读题，分析需求
2. 暴力解法先实现（即使 O(n²)）
3. 理解问题本质

第二遍（优化）：

1. 尝试更好的算法
2. 分析时间和空间复杂度
3. 写出最优解

第三遍（复习）：

1. 一周后重新做
2. 一个月后再做
3. 面试前快速过一遍

6.3 记忆技巧

间隔重复（Spaced Repetition）：

• 使用 Anki 或闪卡软件
• 每天复习旧知识
• 定期测试自己

主动回忆：

• 不要只是看答案
• 合上书本自己写
• 讲解给别人听

6.4 常见错误

错误 1：只看不做

“我看了 8 小时的视频，记了大量笔记，几个月后忘了一大半。”

解决方案： 每学一个知识点，立即做 2-3 道相关题目。

错误 2：死记硬背

“刷了 200 道题，面试遇到新题还是不会。”

解决方案： 理解算法思想，掌握通用模式，而非记忆答案。

错误 3：忽视基础

“上来就刷 hard 题，基础不牢。”

解决方案： 先搞定 easy 和 medium，foundation 扎实后再挑战 hard。

七、面试技巧

7.1 技术面试流程

7.2 代码面试技巧

沟通技巧：

1. Clarify Requirements（明确需求）
2. State Approach（说明思路）
3. Code While Thinking（边想边写）
4. Test Your Solution（测试验证）
5. Discuss Complexity（分析复杂度）

代码规范：

# 好的代码风格
def two_sum(nums, target):
    """
    找到数组中和为目标值的两个数下标
    
    Args:
        nums: 整数数组
        target: 目标值
    
    Returns:
        两个下标的列表，无解返回空列表
    """
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

7.3 行为面试（STAR 方法）

STAR 框架：

• Situation：背景/情境
• Task：任务/挑战
• Action：采取的行动
• Result：取得的结果

常见问题准备：

• 最有挑战的项目
• 团队合作经历
• 解决冲突经验
• 失败教训

7.4 向面试官提问

好的问题：

• 工作日常是什么样的？
• 团队的技术栈是什么？
• 新人如何上手？
• 最大的技术挑战是什么？

避免的问题：

• 薪资福利（等 HR 环节再问）
• 八卦公司负面
• 问 Google 就能找到的答案

八、进阶主题（可选）

8.1 系统设计

适用于 4 年以上经验的候选人：

8.2 额外学习资源

九、学习路线图（完整版）

9.1 时间安排建议

Week 1-2：算法复杂度 + 选择编程语言
Week 3-4：数组、链表、栈、队列
Week 5-6：哈希表、树、堆
Week 7-8：图算法（BFS、DFS）
Week 9-10：排序算法 + 递归
Week 11-14：动态规划
Week 15-16：回溯 + 分治
Week 17-18：系统设计基础
Week 19-20：简历 + 面试技巧
Week 21+：持续刷题 + 模拟面试

9.2 GitHub 任务追踪

CIU 使用 Markdown 任务列表追踪进度：

- [x] 算法复杂度 / Big-O
- [ ] 数组
- [ ] 链表
- [ ] 栈
- [ ] 队列
- [ ] 哈希表

十、总结

10.1 CIU 核心价值

10.2 成功关键

1. 坚持：每天学习，不要中断太久
2. 实践：光学不练假把式
3. 思考：理解本质，而非死记硬背
4. 交流：讲解给他人，深化理解

10.3 心态调整

“成功的软件工程师都很聪明，但很多人有不安全感——觉得自己不够聪明。”

克服方法：

• 看完视频The myth of the Genius Programmer
• 看完视频It’s Dangerous to Go Alone

相关链接

• 🌐 官网：https://github.com/jwasham/coding-interview-university
• 📖 中文翻译：搜索 GitHub Fork
• 📚 推荐书籍：《Cracking the Coding Interview》
• 💬 社区：GitHub Issues / Discussions

🦞 每日08:00自动更新