1. 认知偏见
1.1. 程序员也是人，他们和其他人在软件开发实践中有着同样的认知偏见
1.2. 只有你的同事真正关心你是如何做事的------其他人都只想要一个好的、有效的产品
1.3. 高估了不使用的类型
1.4. 不关心正确数据结构的好处
1.5. 认为算法只对库作者重要
2. 理论
2.1. 理论可以是压倒性的和不相关的
2.2. 算法、数据结构、类型理论、Big-O表示法和多项式复杂度可能看起来很复杂，但与软件开发无关
2.3. 现有的库和框架已经以一种优化和经过良好测试的方式处理了这些问题
2.4. 你永远不要从头开始实现算法，特别是在对信息安全有较高要求或开发时限紧张的情况下
2.5. 为什么关心理论
2.5.1. 从头开始实现算法和数据结构
2.5.2. 正确地决定何时需要使用它们
2.5.3. 帮助你理解不同决策带来的成本
2.5.4. 帮助你理解正在编写的代码的可伸缩性特征
2.5.5. 帮助你向前看
3. 算法
3.1. 一套解决问题的规则和步骤
3.1.1. 它们只需要为你的需要工作
3.1.1.1. 根据你的需要，可以有更智能的算法
3.1.2. 它们不一定要创造奇迹
3.1.3. 它们能一点儿都不聪明，但确实有效，而且有道理
3.1.3.1. 算法本身并不意味着它很聪明
3.2. 检查一个数组的元素以找出它是否包含一个数字
3.2.1. 算法1
3.2.1.1. public static bool Contains(int[] array, int lookFor) {
for (int n = 0; n ＜ array.Length; n++) { if (array[n] == lookFor) { return true; } } return false; }
3.3. 如果你知道数组只包含正整数，你可以为非正数添加特殊处理
3.3.1. 算法2
3.3.1.1. public static bool Contains(int[] array, int lookFor) {
if (lookFor ＜ 1) { return false; } for (int n = 0; n ＜ array.Length; n++) { if (array[n] == lookFor) { return true; } } return false; }
3.3.1.2. 算法运算速度的提升幅度取决于你用负数作参数调用它的次数
3.3.1.3. 在最坏的情况下，你的函数将总是以正数作参数调用，这样就会产生额外的不必要的检查
3.3.2. 算法3
3.3.2.1. public static bool Contains(uint[] array, uint lookFor) {
for (int n = 0; n ＜ array.Length; n++) { if (array[n] == lookFor) { return true; } } return false; }
3.3.2.2. 你总是可以接收到正数，如果你违反了这个规则，编译器会检查它，但不会导致性能问题
3.3.2.3. 类型限制固定了正数需求，而不是改变算法，但根据数据的类型进行处理，还可以使运行速度更快
3.4. 数组排序了
3.4.1. 算法4
3.4.1.1. public static bool Contains(uint[] array, uint lookFor) {
int start = 0; int end = array.Length - 1; while (start ＜= end) { int middle = start + ((end - start) / 2);⇽--- 找到中间点，防止溢出 uint value = array[middle]; if (lookFor == value) { return true; } if (lookFor ＞ value) { start = middle + 1; ⇽--- 消除给定范围的左半边 } else { end = middle - 1; ⇽--- 消除给定范围的右半边 } } return false; }
3.4.1.2. 二分法
3.4.1.2.1. 如果我们从列表的中间选取元素，就可以保证在比较之后至少可以消除列表一半的元素。我们可以把同样的逻辑应用到剩下的一半元素，在那里选一个中间点，然后继续
4. Big-O
4.1. 只是用来解释增长的符号，它容易被误解
4.2. 是数学家解释增长的一种方式
4.3. 不仅用于测量计算步骤，也就是时间复杂度的增加，还用于测量内存使用的增加，这被称为空间复杂度
4.4. O(1)
4.4.1. 意味着性能特征与算法的给定数据结构中的元素数量（也称为常数时间）无关
4.5. O(N )
4.5.1. 按顺序遍历每个元素（又名塞达特算法）所需要的时间与数组中的元素数量成正比
4.5.2. N表示元素个数
4.5.3. Big-O看来，O(N )和O(4N )是等价的
4.6. O(log2^n)
4.6.1. 对数复杂度
4.7. O(N^x)
4.7.1. 并不意味着指数复杂度
4.7.2. 表示多项式复杂度
4.7.3. 没有指数复杂度可怕
4.8. O(x^n )
4.8.1. 指数复杂度
4.9. O(N!)
4.9.1. 阶乘复杂度
4.9.2. 比指数复杂度还要糟糕
4.10. 图
