[转]坚持完成这套学习手册，你就可以去 Google 面试了

这篇转自极客头条的文章，内容特别多，没曾想到，入google大门这么复杂！！
借此篇文章，与大伙共勉吧！
时间足够的情况下，多翻翻，多学学！

• 转自：http://geek.csdn.net/news/detail/107064
• 本文为掘金投稿，译文出自：掘金翻译计划（翻译不易，欢迎 Star 支持）。
• 原文地址：Google Interview University
• 原文作者：John Washam
• 译者：Aleen，Newton，bobmayuze，Jaeger，sqrthree
• 友情提醒：文章较长，需耐心阅读。

这是？

这是我为了从 Web 开发者（自学、非计算机科学学位）蜕变至 Google 软件工程师所制定的计划，其内容历时数月。

这一长列表是从 Google 的指导笔记 中萃取出来并进行扩展。因此，有些事情你必须去了解一下。我在列表的底部添加了一些额外项，用于解决面试中可能会出现的问题。这些额外项大部分是来自于 Steve Yegge 的“得到在 Google 工作的机会”。而在 Google 指导笔记的逐字间，它们有时也会被反映出来。

---

目录

• 这是？
• 为何要用到它？
• 如何使用它
• 拥有一名 Googler 的心态
• 我得到了工作吗？
• 跟随着我
• 不要自以为自己足够聪明
• 关于 Google
• 相关视频资源
• 面试过程 & 通用的面试准备
• 为你的面试选择一种语言
• 在你开始之前
• 你所看不到的
• 日常计划
• 必备知识
• 算法复杂度 / Big-O / 渐进分析法
• 数据结构
  • 数组（Arrays）
  • 链表（Linked Lists）
  • 堆栈（Stack）
  • 队列（Queue）
  • 哈希表（Hash table）
• 更多的知识
  • 二分查找（Binary search）
  • 按位运算（Bitwise operations）
• 树（Trees）
  • 树 —— 笔记 & 背景
  • 二叉查找树（Binary search trees）：BSTs
  • 堆（Heap） / 优先级队列（Priority Queue） / 二叉堆（Binary Heap）
  • 字典树（Tries）
  • 平衡查找树（Balanced search trees）
  • N 叉树（K 叉树、M 叉树）
• 排序
• 图（Graphs）
• 更多知识
  • 递归
  • 动态规划
  • 组合 & 概率
  • NP, NP-完全和近似算法
  • 缓存
  • 进程和线程
  • 系统设计、可伸缩性、数据处理
  • 论文
  • 测试
  • 调度
  • 实现系统例程
  • 字符串搜索和操作
• 终面
• 书籍
• 编码练习和挑战
• 当你临近面试时
• 你的简历
• 当面试来临的时候
• 问面试官的问题
• 当你获得了梦想的职位

—————- 下面的内容是可选的 —————-

• 附加的学习
  • Unicode
  • 字节顺序
  • Emacs and vi(m)
  • Unix 命令行工具
  • 信息资源 (视频)
  • 奇偶校验位 & 汉明码 (视频)
  • 系统熵值（系统复杂度）
  • 密码学
  • 压缩
  • 网络 (视频)
  • 计算机安全
  • 释放缓存
  • 并行/并发编程
  • 设计模式
  • 信息传输, 序列化, 和队列化的系统
  • 快速傅里叶变换
  • 布隆过滤器
  • van Emde Boas 树
  • 更深入的数据结构
  • 跳表
  • 网络流
  • 不相交集 & 联合查找
  • 快速处理数学
  • 树堆 (Treap)
  • 线性规划
  • 几何：凸包（Geometry, Convex hull）
  • 离散数学
  • 机器学习
  • Go 语言
• 一些主题的额外内容
• 视频系列
• 计算机科学课程

---

为何要用到它？

我一直都是遵循该计划去准备 Google 的面试。自 1997 年以来，我一直从事于 Web 程序的构建、服务器的构建及创业型公司的创办。对于只有着一个经济学学位，而不是计算机科学学位（CS degree）的我来说，在职业生涯中所取得的都非常成功。然而，我想在 Google 工作，并进入大型系统中，真正地去理解计算机系统、算法效率、数据结构性能、低级别编程语言及其工作原理。可一项都不了解的我，怎么会被 Google 所应聘呢？

当我创建该项目时，我从一个堆栈到一个堆都不了解。那时的我，完全不了解 Big-O 、树，或如何去遍历一个图。如果非要我去编写一个排序算法的话，我只能说我所写的肯定是很糟糕。一直以来，我所用的任何数据结构都是内建于编程语言当中。至于它们在背后是如何运作，对此我一概不清楚。此外，以前的我并不需要对内存进行管理，最多就只是在一个正在执行的进程抛出了“内存不足”的错误后，采取一些权变措施。而在我的编程生活中，也甚少使用到多维数组，可关联数组却成千上万。而且，从一开始到现在，我都还未曾自己实现过数据结构。

就是这样的我，在经过该学习计划后，已然对被 Google 所雇佣充满信心。这是一个漫长的计划，以至于花费了我数月的时间。若您早已熟悉大部分的知识，那么也许能节省大量的时间。

如何使用它

下面所有的东西都只是一个概述。因此，你需要由上而下逐一地去处理它。

在学习过程中，我是使用 GitHub 特殊的语法特性 markdown flavor 去检查计划的进展，包括使用任务列表。(注：因极客头条的 markdown 并不支持此语法，因此在下方做了删除处理)

更多关于 Github-flavored markdown 的详情

拥有一名 Googler 的心态

把一个（或两个）印有“future Googler”的图案打印出来，并用你誓要成功的眼神盯着它。

我得到了工作吗？

我还没去应聘。

因为我离完成学习（完成该疯狂的计划列表）还需要数天的时间，并打算在下周开始用一整天的时间，以编程的方式去解决问题。当然，这将会持续数周的时间。然后，我才通过使用在二月份所得到的一个介绍资格，去正式应聘 Google（没错，是二月份时就得到的）。

感谢 JP 的这次介绍。

跟随着我

目前我仍在该计划的执行过程中，如果你想跟随我脚步去学习的话，可以登进我在 GoogleyAsHeck.com 上所写的博客。

下面是我的联系方式：

• Twitter: @googleyasheck
• Twitter: @StartupNextDoor
• Google+: +Googleyasheck
• LinkedIn: johnawasham

不要自以为自己足够聪明

• Google 的工程师都是才智过人的。但是，就算是工作在 Google 的他们，仍然会因为自己不够聪明而感到一种不安。
• 天才程序员的神话

关于 Google

• 面向学生 —— Google 的职业生涯：技术开发指导
• Google 检索的原理：
  • Google 检索的发展史（视频）
  • Google 检索的原理 —— 故事篇
  • Google 检索的原理
  • Google 检索的原理 —— Matt Cutts（视频）
  • Google 是如何改善其检索算法（视频）
• 系列文章：
  • Google 检索是如何处理移动设备
  • Google 为了寻找大众需求的秘密研究
  • Google 检索将成为你的下一个大脑
  • Demis Hassabis 的心灵直白
• 书籍：Google 公司是如何运作的
• 由 Google 通告所制作 —— 2016年10月（视频）

相关视频资源

部分视频只能通过在 Coursera、Edx 或 Lynda.com class 上注册登录才能观看。这些视频被称为网络公开课程（MOOC）。即便是免费观看，部分课程可能会由于不在时间段内而无法获取。因此，你需要多等待几个月。

很感谢您能帮我把网络公开课程的视频链接转换成公开的视频源，以代替那些在线课程的视频。此外，一些大学的讲座视频也是我所青睐的。

面试过程 & 通用的面试准备

• 视频：

  • 如何在 Google 工作 —— 考生指导课程（视频）
  • Google 招聘者所分享的技术面试小窍门（视频）
  • 如何在 Google 工作：技术型简历的准备（视频）

• 文章：

  • 三步成为 Googler
  • 得到在 Google 的工作机会
    • 所有他所提及的事情都列在了下面
  • （早已过期） 如何得到 Google 的一份工作，面试题，应聘过程
  • 手机设备屏幕的问题

• 附加的（虽然 Google 不建议，但我还是添加在此）：

  • ABC：永远都要去编程（Always Be Coding）
  • 四步成为 Google 里一名没有学位的员工
  • 共享白板（Whiteboarding）
  • Google 是如何看待应聘、管理和公司文化
  • 程序开发面试中有效的白板（Whiteboarding）
  • 震撼开发类面试 第一集：
    • Gayle L McDowell —— 震撼开发类面试（视频）
    • 震撼开发类面试 —— 作者 Gayle Laakmann McDowell（视频）
  • 如何在世界四强企业中获得一份工作：
    • “如何在世界四强企业中获得一份工作 —— Amazon、Facebook、Google 和 Microsoft”（视频）
  • 面试 Google 失败

为你的面试选择一种语言

在这，我就以下话题写一篇短文 —— 重点：为在 Google 的面试选择一种语言

在大多数公司的面试当中，你可以在编程这一环节，使用一种自己用起来较为舒适的语言去完成编程。但在 Google，你只有三种固定的选择：

• C++
• Java
• Python

有时你也可以使用下面两种，但需要事先查阅说明。因为，说明中会有警告：

• JavaScript
• Ruby

你需要对你所选择的语言感到非常舒适且足够了解。

更多关于语言选择的阅读：

• http://www.byte-by-byte.com/choose-the-right-language-for-your-coding-interview/
• http://blog.codingforinterviews.com/best-programming-language-jobs/
• https://www.quora.com/What-is-the-best-language-to-program-in-for-an-in-person-Google-interview

在此查看相关语言的资源

由于，我正在学习C、C++ 和 Python。因此，在下面你会看到部分关于它们的学习资料。相关书籍请看文章的底部。

在你开始之前

该列表已经持续更新了很长的一段时间，所以，我们的确很容易会对其失去控制。

这里列出了一些我所犯过的错误，希望您不要重滔覆辙。

1. 你不可能把所有的东西都记住

就算我查看了数小时的视频，并记录了大量的笔记。几个月后的我，仍然会忘却其中大部分的东西。所以，我翻阅了我的笔记，并将可回顾的东西制作成抽认卡（flashcard）（请往下看）

2. 使用抽认卡

为了解决善忘的问题，我制作了一些关于抽认卡的页面，用于添加两种抽认卡：正常的及带有代码的。每种卡都会有不同的格式设计。

而且，我还以移动设备为先去设计这些网页，以使得在任何地方的我，都能通过我的手机及平板去回顾知识。

你也可以免费制作属于你自己的抽认卡网站：

• 抽认卡页面的代码仓库
• 我的抽认卡数据库：有一点需要记住的是，我做事有点过头，以至于把卡片都覆盖到所有的东西上。从汇编语言和 Python 的细枝末节，乃至到机器学习和统计都被覆盖到卡片上。而这种做法，对于 Google 的要求来说，却是多余。

在抽认卡上做笔记： 若你第一次发现你知道问题的答案时，先不要急着把其标注成“已懂”。你需要做的，是去查看一下是否有同样的抽认卡，并在你真正懂得如何解决问题之前，多问自己几次。重复地问答可帮助您深刻记住该知识点。

3. 回顾，回顾，回顾

我留有一组 ASCII 码表、OSI 堆栈、Big-O 记号及更多的小抄纸，以便在空余的时候可以学习。

每编程半个小时就要休息一下，并去回顾你的抽认卡。

4. 专注

在学习的过程中，往往会有许多令人分心的事占据着我们宝贵的时间。因此，专注和集中注意力是非常困难的。

你所看不到的

由于，这个巨大的列表一开始是作为我个人从 Google 面试指导笔记所形成的一个事件处理列表。因此，有一些我熟悉且普遍的技术在此都未被谈及到：

• SQL
• Javascript
• HTML、CSS 和其他前端技术

日常计划

部分问题可能会花费一天的时间去学习，而部分则会花费多天。当然，有些学习并不需要我们懂得如何实现。

因此，每一天我都会在下面所列出的列表中选择一项，并查看相关的视频。然后，使用以下的一种语言去实现：

C —— 使用结构体和函数，该函数会接受一个结构体指针 * 及其他数据作为参数。
C++ —— 不使用内建的数据类型。
C++ —— 使用内建的数据类型，如使用 STL 的 std::list 来作为链表。
Python ——  使用内建的数据类型（为了持续练习 Python），并编写一些测试去保证自己代码的正确性。有时，只需要使用断言函数 assert() 即可。
此外，你也可以使用 Java 或其他语言。以上只是我的个人偏好而已。

为何要在这些语言上分别实现一次？

因为可以练习，练习，练习，直至我厌倦它，并完美地实现出来。（若有部分边缘条件没想到时，我会用书写的形式记录下来并去记忆）
因为可以在纯原生的条件下工作（不需垃圾回收机制的帮助下，分配/释放内存（除了 Python））
因为可以利用上内建的数据类型，以使得我拥有在现实中使用内建工具的经验（在生产环境中，我不会去实现自己的链表）

就算我没有时间去每一项都这么做，但我也会尽我所能的。

在这里，你可以查看到我的代码：

• C
• C++
• Python

你不需要记住每一个算法的内部原理。

在一个白板上写代码，而不要直接在计算机上编写。在测试完部分简单的输入后，到计算机上再测试一遍。

必备知识

• 计算机是如何处理一段程序：

  • CPU 是如何执行代码（视频）
  • 机器码指令（视频）

• 编译器

  • 编译器是如何在 ~1 分钟内工作（视频）
  • Hardvard CS50 —— 编译器（视频）
  • C++（视频）
  • 掌握编译器的优化（C++）（视频）

• 浮点数是如何存储的：

  • 简单的 8-bit：浮点数的表达形式　—— 1（视频 —— 在计算上有一个错误 —— 详情请查看视频的介绍）
  • 32 bit：IEEE754 32-bit 浮点二进制（视频）

算法复杂度 / Big-O / 渐进分析法

• 并不需要实现
• Harvard CS50 —— 渐进表示（视频）
• Big O 记号（通用快速教程）（视频）
• Big O 记号（以及 Omega 和 Theta）—— 最佳数学解释（视频）
• Skiena 算法：
  • 视频
  • 幻灯片
• 对于算法复杂度分析的一次详细介绍
• 增长阶数（Orders of Growth）（视频）
• 渐进性（Asymptotics）（视频）
• UC Berkeley Big O（视频）
• UC Berkeley Big Omega（视频）
• 平摊分析法（Amortized Analysis）（视频）
• 举证“Big O”（视频）
• 高级编程（包括递归关系和主定理）：
  • 计算性复杂度：第一部
  • 计算性复杂度：第二部

• 速查表（Cheat sheet）

  如果部分课程过于学术性，你可直接跳到文章底部，去查看离散数学的视频以获取相关背景知识。

数据结构

• 数组（Arrays）

  • 实现一个可自动调整大小的动态数组。
  • 介绍：
    • 数组（视频）
    • 数组的基础知识（视频）
    • 多维数组（视频）
    • 动态数组（视频）
    • 不规则数组（视频）
    • 调整数组的大小（视频）
  • 实现一个动态数组（可自动调整大小的可变数组）：
    • 练习使用数组和指针去编码，并且指针是通过计算去跳转而不是使用索引
    • 通过分配内存来新建一个原生数据型数组
      • 可以使用 int 类型的数组，但不能使用其语法特性
      • 从大小为16或更大的数（使用2的倍数 —— 16、32、64、128）开始编写
    • size() —— 数组元素的个数
    • capacity() —— 可容纳元素的个数
    • is_empty()
    • at(index) —— 返回对应索引的元素，且若索引越界则愤然报错
    • push(item)
    • insert(index, item) —— 在指定索引中插入元素，并把后面的元素依次后移
    • prepend(item) —— 可以使用上面的 insert 函数，传参 index 为 0
    • pop() —— 删除在数组末端的元素，并返回其值
    • delete(index) —— 删除指定索引的元素，并把后面的元素依次前移
    • remove(item) —— 删除指定值的元素，并返回其索引（即使有多个元素）
    • find(item) —— 寻找指定值的元素并返回其中第一个出现的元素其索引，若未找到则返回 -1
    • resize(new_capacity) // 私有函数
      • 若数组的大小到达其容积，则变大一倍
      • 获取元素后，若数组大小为其容积的1/4，则缩小一半
  • 时间复杂度
    • 在数组末端增加/删除、定位、更新元素，只允许占 O(1) 的时间复杂度（平摊（amortized）去分配内存以获取更多空间）
    • 在数组任何地方插入/移除元素，只允许 O(n) 的时间复杂度
  • 空间复杂度
    • 因为在内存中分配的空间邻近，所以有助于提高性能
    • 空间需求 = （大于或等于 n 的数组容积）* 元素的大小。即便空间需求为 2n，其空间复杂度仍然是 O(n)

• 链表（Linked Lists）

  • 介绍：
    • 单向链表（视频）
    • CS 61B —— 链表（视频）
  • C 代码（视频）
    • 并非看完整个视频，只需要看关于节点结果和内存分配那一部分即可
  • 链表 vs 数组：
    • 基本链表 Vs 数组（视频）
    • 在现实中，链表 Vs 数组（视频）
  • 为什么你需要避免使用链表（视频）
  • 的确：你需要关于“指向指针的指针”的相关知识：（因为当你传递一个指针到一个函数时，该函数可能会改变指针所指向的地址）该页只是为了让你了解“指向指针的指针”这一概念。但我并不推荐这种链式遍历的风格。因为，这种风格的代码，其可读性和可维护性太低。
    • 指向指针的指针
  • 实现（我实现了使用尾指针以及没有使用尾指针这两种情况）：
    • size() —— 返回链表中数据元素的个数
    • empty() —— 若链表为空则返回一个布尔值 true
    • value_at(index) —— 返回第 n 个元素的值（从0开始计算）
    • push_front(value) —— 添加元素到链表的首部
    • pop_front() —— 删除首部元素并返回其值
    • push_back(value) —— 添加元素到链表的尾部
    • pop_back() —— 删除尾部元素并返回其值
    • front() —— 返回首部元素的值
    • back() —— 返回尾部元素的值
    • insert(index, value) —— 插入值到指定的索引，并把当前索引的元素指向到新的元素
    • erase(index) —— 删除指定索引的节点
    • value_n_from_end(n) —— 返回倒数第 n 个节点的值
    • reverse() —— 逆序链表
    • remove_value(value) —— 删除链表中指定值的第一个元素
  • 双向链表
    • 介绍（视频）
    • 并不需要实现

• 堆栈（Stack）

  • 堆栈（视频）
  • 使用堆栈 —— 后进先出（视频）
  • 可以不实现，因为使用数组来实现并不重要

• 队列（Queue）

  • 使用队列 —— 先进先出（视频）
  • 队列（视频）
  • 原型队列/先进先出（FIFO）
  • 优先级队列（视频）
  • 使用含有尾部指针的链表来实现:
    • enqueue(value) —— 在尾部添加值
    • dequeue() —— 删除最早添加的元素并返回其值（首部元素）
    • empty()
  • 使用固定大小的数组实现：
    • enqueue(value) —— 在可容的情况下添加元素到尾部
    • dequeue() —— 删除最早添加的元素并返回其值
    • empty()
    • full()
  • 花销：
    • 在糟糕的实现情况下，使用链表所实现的队列，其入列和出列的时间复杂度将会是 O(n)。因为，你需要找到下一个元素，以致循环整个队列
    • enqueue：O(1)（平摊（amortized）、链表和数组 [探测（probing）]）
    • dequeue：O(1)（链表和数组）
    • empty：O(1)（链表和数组）

• 哈希表（Hash table）

  • 视频：

    • 链式哈希表（视频）
    • Table Doubling 和 Karp-Rabin（视频）
    • Open Addressing 和密码型哈希（Cryptographic Hashing）（视频）
    • PyCon 2010：The Mighty Dictionary（视频）
    • （进阶）随机取样（Randomization）：全域哈希（Universal Hashing）& 完美哈希（Perfect Hashing）（视频）
    • （进阶）完美哈希（Perfect hashing）（视频）

  • 在线课程：

    • 哈希函数的掌握（视频）
    • 使用哈希表（视频）
    • 哈希表的支持（视频）
    • 哈希表的语言支持（视频）
    • 基本哈希表（视频）
    • 数据结构（视频）
    • 电话薄问题（Phone Book Problem）（视频）
    • 分布式哈希表：
      • Dropbox 中的瞬时上传及存储优化（视频）
      • 分布式哈希表（视频）

  • 使用线性探测的数组去实现

    • hash(k, m) —— m 是哈希表的大小
    • add(key, value) —— 如果 key 已存在则更新值
    • exists(key)
    • get(key)
    • remove(key)

更多的知识

• 二分查找（Binary search）

  • 二分查找（视频）
  • 二分查找（视频）
  • 详情
  • 实现：
    • 二分查找（在一个已排序好的整型数组中查找）
    • 迭代式二分查找

• 按位运算（Bitwise operations）

  • Bits 速查表
    • 你需要知道大量2的幂数值（从2^1 到 2^16 及 2^32）
  • 好好理解位操作符的含义：&、|、^、~、>>、<<
    • 字码（words）
    • 好的介绍：
      位操作（视频）
    • C 语言编程教程 2-10：按位运算（视频）
    • 位操作
    • 按位运算
    • Bithacks
    • 位元抚弄者（The Bit Twiddler）
    • 交互式位元抚弄者（The Bit Twiddler Interactive）
  • 一补数和补码
    • 二进制：利 & 弊（为什么我们要使用补码）（视频）
    • 一补数（1s Complement）
    • 补码（2s Complement）
  • 计算置位（Set Bits）
    • 计算一个字节中置位（Set Bits）的四种方式（视频）
    • 计算比特位
    • 如何在一个 32 位的整型中计算置位（Set Bits）的数量
  • 四舍五入2的幂数：
    • 四舍五入到2的下一幂数
  • 交换值：
    • 交换（Swap）
  • 绝对值：
    • 绝对整型（Absolute Integer）

树（Trees）

• 树 —— 笔记 & 背景

  • 系列：基本树（视频）
  • 系列：树（视频）
  • 基本的树形结构
  • 遍历
  • 操作算法
  • BFS（广度优先检索，breadth-first search）
    • MIT（视频）
    • 层序遍历（使用队列的 BFS 算法）
      • 时间复杂度： O(n)
      • 空间复杂度：
        • 最好情况： O(1)
        • 最坏情况：O(n/2)=O(n)
  • DFS（深度优先检索，depth-first search）
    • MIT（视频）
    • 笔记：
      • 时间复杂度：O(n)
      • 空间复杂度：
        • 最好情况：O(log n) – 树的平均高度
        • 最坏情况：O(n)
    • 中序遍历（DFS：左、节点本身、右）
    • 后序遍历（DFS：左、右、节点本身）
    • 先序遍历（DFS：节点本身、左、右）

• 二叉查找树（Binary search trees）：BSTs

  • 二叉查找树概览（视频）
  • 系列（视频）
    • 从符号表开始到 BST 程序
  • 介绍（视频）
  • MIT（视频）
  • C/C++:
    • 二叉查找树 —— 在 C/C++ 中实现（视频）
    • BST 的实现 —— 在堆栈和堆中的内存分配（视频）
    • 在二叉查找树中找到最小和最大的元素（视频）
    • 寻找二叉树的高度（视频）
    • 二叉树的遍历 —— 广度优先和深度优先策略（视频）
    • 二叉树：层序遍历（视频）
    • 二叉树的遍历：先序、中序、后序（视频）
    • 判断一棵二叉树是否为二叉查找树（视频）
    • 从二叉查找树中删除一个节点（视频）
    • 二叉查找树中序遍历的后继者（视频）
  • 实现：
    • insert // 往树上插值
    • get_node_count // 查找树上的节点数
    • print_values // 从小到大打印树中节点的值
    • delete_tree
    • is_in_tree // 如果值存在于树中则返回 true
    • get_height // 返回节点所在的高度（如果只有一个节点，那么高度则为1）
    • get_min // 返回树上的最小值
    • get_max // 返回树上的最大值
    • is_binary_search_tree
    • delete_value
    • get_successor // 返回给定值的后继者，若没有则返回-1

• 堆（Heap） / 优先级队列（Priority Queue） / 二叉堆（Binary Heap）

  • 可视化是一棵树，但通常是以线性的形式存储（数组、链表）
  • 堆
  • 介绍（视频）
  • 无知的实现（视频）
  • 二叉树（视频）
  • 关于树高的讨论（视频）
  • 基本操作（视频）
  • 完全二叉树（视频）
  • 伪代码（视频）
  • 堆排序 —— 跳到起点（视频）
  • 堆排序（视频）
  • 构建一个堆（视频）
  • MIT：堆与堆排序（视频）
  • CS 61B Lecture 24：优先级队列（视频）
  • 构建线性时间复杂度的堆（大顶堆）
  • 实现一个大顶堆：
    • insert
    • sift_up —— 用于插入元素
    • get_max —— 返回最大值但不移除元素
    • get_size() —— 返回存储的元素数量
    • is_empty() —— 若堆为空则返回 true
    • extract_max —— 返回最大值并移除
    • sift_down —— 用于获取最大值元素
    • remove(i) —— 删除指定索引的元素
    • heapify —— 构建堆，用于堆排序
    • heap_sort() —— 拿到一个未排序的数组，然后使用大顶堆进行就地排序
      • 注意：若用小顶堆可节省操作，但导致空间复杂度加倍。（无法做到就地）

• 字典树（Tries）

  • 需要注意的是，字典树各式各样。有些有前缀，而有些则没有。有些使用字符串而不使用比特位来追踪路径。
  • 阅读代码，但不实现。
  • 数据结构笔记及编程技术
  • 短课程视频：
    • 对字典树的介绍（视频）
    • 字典树的性能（视频）
    • 实现一棵字典树（视频）
  • 字典树：一个被忽略的数据结构
  • 高级编程 —— 使用字典树
  • 标准教程（现实中的用例）（视频）
  • MIT，高阶数据结构，使用字符串追踪路径（可事半功倍）

• 平衡查找树（Balanced search trees）

  • 掌握至少一种平衡查找树（并懂得如何实现）：
  • “在各种平衡查找树当中，AVL 树和2-3树已经成为了过去，而红黑树（red-black trees）看似变得越来越受人青睐。这种令人特别感兴趣的数据结构，亦称伸展树（splay tree）。它可以自我管理，且会使用轮换来移除任何访问过根节点的 key。” —— Skiena
  • 因此，在各种各样的平衡查找树当中，我选择了伸展树来实现。虽然，通过我的阅读，我发现在 Google 的面试中并不会被要求实现一棵平衡查找树。但是，为了胜人一筹，我们还是应该看看如何去实现。在阅读了大量关于红黑树的代码后，我才发现伸展树的实现确实会使得各方面更为高效。
    • 伸展树：插入、查找、删除函数的实现，而如果你最终实现了红黑树，那么请尝试一下：
    • 跳过删除函数，直接实现搜索和插入功能
  • 我希望能阅读到更多关于 B 树的资料，因为它也被广泛地应用到大型的数据库当中。

  • 自平衡二叉查找树

  • AVL 树

    • 实际中：我能告诉你的是，该种树并无太多的用途，但我能看到有用的地方在哪里：AVL 树是另一种平衡查找树结构。其可支持时间复杂度为 O(log n) 的查询、插入及删除。它比红黑树严格意义上更为平衡，从而导致插入和删除更慢，但遍历却更快。正因如此，才彰显其结构的魅力。只需要构建一次，就可以在不重新构造的情况下读取，适合于实现诸如语言字典（或程序字典，如一个汇编程序或解释程序的操作码）。
    • MIT AVL 树 / AVL 树的排序（视频）
    • AVL 树（视频）
    • AVL 树的实现（视频）
    • 分离与合并

  • 伸展树

    • 实际中：伸展树一般用于缓存、内存分配者、路由器、垃圾回收者、数据压缩、ropes（字符串的一种替代品，用于存储长串的文本字符）、Windows NT（虚拟内存、网络及文件系统）等的实现。
    • CS 61B：伸展树（Splay trees）（视频）
    • MIT 教程：伸展树（Splay trees）：
      • 该教程会过于学术，但请观看到最后的10分钟以确保掌握。
      • 视频

  • 2-3查找树

    • 实际中：2-3树的元素插入非常快速，但却有着查询慢的代价（因为相比较 AVL 树来说，其高度更高）。
    • 你会很少用到2-3树。这是因为，其实现过程中涉及到不同类型的节点。因此，人们更多地会选择红黑树。
    • 2-3树的直感与定义（视频）
    • 2-3树的二元观点
    • 2-3树（学生叙述）（视频）

  • 2-3-4树 (亦称2-4树)

    • 实际中：对于每一棵2-4树，都有着对应的红黑树来存储同样顺序的数据元素。在2-4树上进行插入及删除操作等同于在红黑树上进行颜色翻转及轮换。这使得2-4树成为一种用于掌握红黑树背后逻辑的重要工具。这就是为什么许多算法引导文章都会在介绍红黑树之前，先介绍2-4树，尽管2-4树在实际中并不经常使用。
    • CS 61B Lecture 26：平衡查找树（视频）
    • 自底向上的2-4树（视频）
    • 自顶向下的2-4树（视频）

  • B 树

    • 有趣的是：为啥叫 B 仍然是一个神秘。因为 B 可代表波音（Boeing）、平衡（Balanced）或 Bayer（联合创造者）
    • 实际中：B 树会被广泛适用于数据库中，而现代大多数的文件系统都会使用到这种树（或变种)。除了运用在数据库中，B 树也会被用于文件系统以快速访问一个文件的任意块。但存在着一个基本的问题，那就是如何将文件块 i 转换成一个硬盘块（或一个柱面-磁头-扇区）上的地址。
    • B 树
    • B 树的介绍（视频）
    • B 树的定义及其插入操作（视频）
    • B 树的删除操作（视频）
    • MIT 6.851 —— 内存层次模块（Memory Hierarchy Models）（视频）
      • 覆盖有高速缓存参数无关型（cache-oblivious）B 树和非常有趣的数据结构
      • 头37分钟讲述的很专业，或许可以跳过（B 指块的大小、即缓存行的大小）

  • 红黑树

    • 实际中：红黑树提供了在最坏情况下插入操作、删除操作和查找操作的时间保证。这些时间值的保障不仅对时间敏感型应用有用，例如实时应用，还对在其他数据结构中块的构建非常有用，而这些数据结构都提供了最坏情况下的保障；例如，许多用于计算几何学的数据结构都可以基于红黑树，而目前 Linux 系统所采用的完全公平调度器（the Completely Fair Scheduler）也使用到了该种树。在 Java 8中，红黑树也被用于存储哈希列表集合中相同的数据，而不是使用链表及哈希码。
    • Aduni —— 算法 —— 课程4（该链接直接跳到开始部分）（视频）
    • Aduni —— 算法 —— 课程5（视频）
    • 黑树（Black Tree）
    • 二分查找及红黑树的介绍

• N 叉树（K 叉树、M 叉树）

  • 注意：N 或 K 指的是分支系数（即树的最大分支数）：
    • 二叉树是一种分支系数为2的树
    • 2-3树是一种分支系数为3的树
  • K 叉树

排序（Sorting）

• 笔记:

  • 实现各种排序 & 知道每种排序的最坏、最好和平均的复杂度分别是什么场景:
    • 不要用冒泡排序 – 大多数情况下效率感人 – 时间复杂度 O(n^2), 除非 n <= 16
  • 排序算法的稳定性 (“快排是稳定的么?”)
    • 排序算法的稳定性
    • 排序算法的稳定性
    • 排序算法的稳定性
    • 排序算法的稳定性
    • 排序算法 – 稳定性
  • 哪种排序算法可以用链表？哪种用数组？哪种两者都可？
    • 并不推荐对一个链表排序，但归并排序是可行的.
    • 链表的归并排序

• 关于堆排序，请查看前文堆的数据结构部分。堆排序很强大，不过是非稳定排序。

• 冒泡排序 (video)

• 冒泡排序分析 (video)
• 插入排序 & 归并排序 (video)
• 插入排序 (video)
• 归并排序 (video)
• 快排 (video)

• 选择排序 (video)

• 斯坦福大学关于排序算法的视频:

  • 课程 15 | 编程抽象 (video)
  • 课程 16 | 编程抽象 (video)

• Shai Simonson 视频, Aduni.org:

  • 算法 – 排序 – 第二讲 (video)
  • 算法 – 排序2 – 第三讲 (video)

• Steven Skiena 关于排序的视频:

  • 课程从 26:46 开始 (video)
  • 课程从 27:40 开始 (video)
  • 课程从 35:00 开始 (video)
  • 课程从 23:50 开始 (video)

• 加州大学伯克利分校（UC Berkeley） 大学课程:

  • CS 61B 课程 29: 排序 I (video)
  • CS 61B 课程 30: 排序 II (video)
  • CS 61B 课程 32: 排序 III (video)
  • CS 61B 课程 33: 排序 V (video)
• • 归并排序:
  • 使用外部数组
  • 对原数组直接排序
• • 快速排序:
  • 实现
  • 实现

• 实现:

  • 归并：平均和最差情况的时间复杂度为 O(n log n)。
  • 快排：平均时间复杂度为 O(n log n)。
  • 选择排序和插入排序的最坏、平均时间复杂度都是 O(n^2)。
  • 关于堆排序，请查看前文堆的数据结构部分。

• 有兴趣的话，还有一些补充 – 但并不是必须的:

  • 基数排序
  • 基数排序 (video)
  • 基数排序, 计数排序 (线性时间内) (video)
  • 随机算法: 矩阵相乘, 快排, Freivalds’ 算法 (video)
  • 线性时间内的排序 (video)

图（Graphs）

图论能解决计算机科学里的很多问题，所以这一节会比较长，像树和排序的部分一样。

• Yegge 的笔记:

  • 有 3 种基本方式在内存里表示一个图:
    • 对象和指针
    • 矩阵
    • 邻接表
  • 熟悉以上每一种图的表示法，并了解各自的优缺点
  • 宽度优先搜索和深度优先搜索 – 知道它们的计算复杂度和设计上的权衡以及如何用代码实现它们
  • 遇到一个问题时，首先尝试基于图的解决方案，如果没有再去尝试其他的。

• Skiena 教授的课程 – 很不错的介绍:

  • CSE373 2012 – 课程 11 – 图的数据结构 (video)
  • CSE373 2012 – 课程 12 – 广度优先搜索 (video)
  • CSE373 2012 – 课程 13 – 图的算法 (video)
  • CSE373 2012 – 课程 14 – 图的算法 (1) (video)
  • CSE373 2012 – 课程 15 – 图的算法 (2) (video)
  • CSE373 2012 – 课程 16 – 图的算法 (3) (video)

• 图 (复习和其他):

  • 6.006 单源最短路径问题 (video)
  • 6.006 Dijkstra 算法 (video)
  • 6.006 Bellman-Ford 算法(video)
  • 6.006 Dijkstra 效率优化 (video)
  • Aduni: 图的算法 I – 拓扑排序, 最小生成树, Prim 算法 – 第六课 (video)
  • Aduni: 图的算法 II – 深度优先搜索, 广度优先搜索, Kruskal 算法, 并查集数据结构 – 第七课 (video)
  • Aduni: 图的算法 III: 最短路径 – 第八课 (video)
  • Aduni: 图的算法. IV: 几何算法介绍 – 第九课 (video)
  • CS 61B 2014 (从 58:09 开始) (video)
  • CS 61B 2014: 加权图 (video)
  • 贪心算法: 最小生成树 (video)
  • 图的算法之强连通分量 Kosaraju 算法 (video)

• 完整的 Coursera 课程:

  • 图的算法 (video)

• Yegge: 如果有机会，可以试试研究更酷炫的算法:

  • Dijkstra 算法 – 上文 – 6.006
  • A* 算法
    • A* 算法
    • A* 寻路教程 (video)
    • A* 寻路 (E01: 算法解释) (video)

• 我会实现:

  • DFS 邻接表 (递归)
  • DFS 邻接表 (栈迭代)
  • DFS 邻接矩阵 (递归)
  • DFS 邻接矩阵 (栈迭代)
  • BFS 邻接表
  • BFS 邻接矩阵
  • 单源最短路径问题 (Dijkstra)
  • 最小生成树
  • 基于 DFS 的算法 (根据上文 Aduni 的视频):
    • 检查环 (我们会先检查是否有环存在以便做拓扑排序)
    • 拓扑排序
    • 计算图中的连通分支
    • 列出强连通分量
    • 检查双向图

可以从 Skiena 的书（参考下面的书推荐小节）和面试书籍中学习更多关于图的实践。

更多知识

• 递归（Recursion）

  • Stanford 大学关于递归 & 回溯的课程:
    • 课程 8 | 抽象编程 (video)
    • 课程 9 | 抽象编程 (video)
    • 课程 10 | 抽象编程 (video)
    • 课程 11 | 抽象编程 (video)
  • 什么时候适合使用
  • 尾递归会更好么?
    • 什么是尾递归以及为什么它如此糟糕?
    • 尾递归 (video)

• 动态规划（Dynamic Programming）

  • This subject can be pretty difficult, as each DP soluble problem must be defined as a recursion relation, and coming up with it can be tricky.
  • 这一部分会有点困难，每个可以用动态规划解决的问题都必须先定义出递推关系，要推导出来可能会有点棘手。

  • 我建议先阅读和学习足够多的动态规划的例子，以便对解决 DP 问题的一般模式有个扎实的理解。

  • 视频:

    • Skiena 的视频可能会有点难跟上，有时候他用白板写的字会比较小，难看清楚。
    • Skiena: CSE373 2012 – 课程 19 – 动态规划介绍 (video)
    • Skiena: CSE373 2012 – 课程 20 – 编辑距离 (video)
    • Skiena: CSE373 2012 – 课程 21 – 动态规划举例 (video)
    • Skiena: CSE373 2012 – 课程 22 – 动态规划应用 (video)
    • Simonson: 动态规划 0 (starts at 59:18) (video)
    • Simonson: 动态规划 I – 课程 11 (video)
    • Simonson: 动态规划 II – 课程 12 (video)
    • 单独的 DP 问题 (每一个视频都很短):
      动态规划 (video)
  • Yale 课程笔记:
    • 动态规划
  • Coursera 课程:
    • RNA 二级结构问题 (video)
    • 动态规划算法 (video)
    • DP 算法描述 (video)
    • DP 算法的运行时间 (video)
    • DP vs 递归实现 (video)
    • 全局成对序列排列 (video)
    • 本地成对序列排列 (video)

• 组合（Combinatorics） (n 中选 k 个) & 概率（Probability）

  • 数据技巧: 如何找出阶乘、排列和组合(选择) (video)
  • 来点学校的东西: 概率 (video)
  • 来点学校的东西: 概率和马尔可夫链 (video)
  • 可汗学院:
    • 课程设置:
      • 概率理论基础
    • 视频 – 41 (每一个都短小精悍):
      • 概率解释 (video)

• NP, NP-完全和近似算法

  • 知道最经典的一些 NP 完全问题，比如旅行商问题和背包问题,
    而且能在面试官试图忽悠你的时候识别出他们。
  • 知道 NP 完全是什么意思.
  • 计算复杂度 (video)
  • Simonson:
    • 贪心算法. II & 介绍 NP-完全性 (video)
    • NP-完全性 II & 归约 (video)
    • NP-完全性 III (Video)
    • NP-完全性 IV (video)
  • Skiena:
    • [CSE373 2012 – 课程 23 – 介绍 NP-完全性 IV (