1.数据结构与算法
1.1何为数据结构
【百度百科】 数据结构（Data Structure）是带有结构特性的数据元素的集合，它研究的是数据的逻辑结构和数据的物理结构以及它们之间的相互关系，并 对这种结构定义相适应的运算，设计出相应的算法，并确保经过这些运算以后所得到的新结构仍保持原来的结构类型。简而言之，数据结构是相互之间存在一种或多种特定关系的数据元素的集合，即带“结构”的数据元素的集合。“结构”就是指数据元素之间存在的关系，分为逻辑结构和存储结构。
数据结构（Data Structure）是计算机存储、组织数据的方式，指相互相之间存在一种或多种特定关系的数据元素的集合。
学习数据结构有什么意义？
数据结构就是有些项目在实现过程中，我们需要在内存中把数据存储起来：数组（虽然方便但是扩容比较麻烦）、链表（用指针链接起来）、树（查找）、哈希表……等等。
1.2何为算法
【百度百科】算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。
定义：算法（Algorithm），即定义良好的计算过程，它取一个或一组的值输入，并产生出一个或一组的值作为输出。简单来说，算法就是一系列的计算步骤，用来将输入数据转化成输出结果。
为什么要学习算法？
举个简单的例子：某音的推荐算法，比如记录用户经常在哪个视频停留时间长从而进行分析，你经常看什么视频，它就会给你推送什么。不难看出，算法已经无处不在了。
2.算法的复杂度
介绍：算法在编写成可执行程序后，运行时需要耗费 时间资源 和 空间资源（即内存资源）。因此，衡量一个算法的好坏一般是从 "时间" 和 "空间" 两个维度来衡量的，即 时间复杂度 和 空间复杂度 ：
① 时间复杂度：主要衡量一个算法的运行快慢。
② 空间复杂度：主要衡量一个算法运行所需要的额外空间。
须知：在计算机发展早期，计算机的存储容量很小，所以大家都很在乎空间复杂度。但是经过计算机行业的迅速发展，现在电脑内存越来越大了，内存也越来越便宜了。所以我们如今不再关注 "空间" ，已经不需要再特别关注一个算法的空间复杂度了。
摩尔定律（英特尔创始人之一戈登·摩尔的经验之谈）：其核心内容为，集成电路上可以容纳的晶体管数目在大约每经过18个月便会增加一倍。换言之，处理器的性能每隔两年翻一倍。它一定程度揭示了信息技术进步的速度，现代计算机发展就像开了挂一样地快。
注：复杂度在校招中的考察很多，校园招聘在笔试算法题和面试中都会考察对复杂度的计算和理解。此外，考研也是必考复杂度。
2.1 时间复杂度的概念
时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数（这里的函数是数学里的函数，数学里面带有未知数的函数表达式），它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上来说其实是不能算出来的，只有你把你的程序放在机器上跑起来才能知道耗费了多少时间。但是把每个算法都跑一遍是非常不现实的事，所以就产生了时间复杂度这样的分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。
该如何计算时间复杂度呢？
简单来说就是：找到某条基本语句与问题规模 N 之间的数学表达式，就是算出了该算法的时间复杂度。
例子：计算一下 Func1 中 ++count 语句总共执行了多少次？
void Func1(int N) { int count = 0; for (int i = 0; i < N; ++i) { for (int j = 0; j < N; j++) { ++count; } } for (int k = 0; k < 2 * N; ++k) { ++count; } int M = 10; while (M--) { ++count; } printf("%d\n", count); }
Func1 执行的基本操作次数如下：
N = 10 F(N) = 130
N = 100 F(N) = 10210
N = 1000 F(N) = 1002010
N 越大，后两项对结果的影响就越小，所以我们也不需要精确的计算出结果，算个大概就可以了。
所以将使用 大O渐进表示法 进行表示。
2.2大O渐进表示法
【百度百科】大O符号（Big O notation）是用于描述函数渐进行为的数学符号。更确切地说，它是用另一个（通常更简单的）函数来描述一个函数数量级的渐近上界。在数学中，
它一般用来刻画被截断的无穷级数尤其是渐近级数的剩余项。
在计算机科学中，它在分析算法复杂性的方面非常有用。
定义：大O符号是用于描述函数渐进性为的数学符号。
推导大O阶方法：
① 用 常数1 取代运行时间中的所有加法常数。
② 在修改后的运行次数函数中，只保留最高阶项。
③ 如果最高阶 存在且不是1 ，则去除与这个项目相乘的常数。最后得到的结果就是大O阶。
使用大O渐进表示法后，Func1 的时间复杂度为 O(N^2) ：
N = 10 F(N) = 100
N = 100 F(N) = 10000
N = 1000 F(N) = 1000000
（看到大O就知道这里面的值不是准确的值，而是大概值）
注意事项：
① 一般情况下，时间复杂度计算式未知数都是用的 N，但是也可以是 M、K、X 等等其他的，
如果出现其他字母（非N）的情况情况我们可以这么表示：
如果 M 远大于 N → O(M)
如果 N 远大于 M → O(N)
M 和 N 差不多大 → O(M + N)
② O(1) 不是代表算法运行一次，而是 "常数次" 。
通过上面的例子，我们发现大O渐进表示法去掉了那些对结果影响不大的项，
简洁明了的表示出了执行次数。
另外有些算法的时间复杂度存在最好情况、平均情况、最坏情况：
① 最好情况：任意输入规模的最小运行次数（下界）
② 平均情况：任意输入规模的期望运行次数
③ 最坏情况：任意输入规模最大的运行次数（上界）
时间复杂度是一个悲观的预期，当一个算法随着输入不同、时间复杂度不同，做一个悲观的预期， 看最坏的情况！
例子：在一个长度为N的数组
① 最好情况：1 次找到
② 最坏情况：N 次找到
③ 平均情况：N/2 次找到
在实际中，一般情况下我们主要关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N) 。当然，这不是绝对的！比如希尔排序很少出现最坏的情况，所以有时候我们也会看平均情况。
一般情况下，时间复杂度计算式未知数都是用的 N，但是也可以是 M、K、X 等等其他的，
如果出现其他字母（非N）的情况情况我们可以这么表示：
如果 M 远大于 N → O(M)
如果 N 远大于 M → O(N)
M 和 N 差不多大 → O(M + N)
实例1：计算 Func2 的时间复杂度
void Func2(int N) { int count = 0; for (int k = 0; k < 2 * N ; ++ k) { ++count; } int M = 10; while (M--) { ++count; } printf("%d\n", count); }
O(N)
解析：基本操作执行了 2N+10 次，通过推导大O阶方法知道，时间复杂度为 O(N) 。因为当N越大，对10的影响就越小，所以+10省略。并且2N根据第三条规则（前面讲了），相乘时不是1时系数忽略，所以使用大O渐进法表示结果如下：
我们带到题里再看一遍规则：
① 用 常数1 取代运行时间中的所有加法常数。
② 在修改后的运行次数函数中，只保留最高阶项。
③ 如果最高阶 存在且不是1 ，则去除与这个项目相乘的常数。最后得到的结果就是大O阶。
为什么不算 ++k ？
我们不需要算的那么精确，我们只需要算循环的次数，指的是算法逻辑走了多少次，
而不是程序走了多少条指令。所以我们不需要考虑 ++k 。
实例2：计算 Func3 的时间复杂度
void Func3(int N, int M) { int count = 0; for (int k = 0; k < M; ++ k) { ++count; } for (int k = 0; k < N ; ++ k) { ++count; } printf("%d\n", count); }
答案：O(M + N)
解析：基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(M+N）。
一般情况下时间复杂度计算时未知数用的是N，但是也可以用其他未知数表示（前面讲过），
所以使用大O渐进法表示结果如下：
为了加深印象，我们再看一遍：
一般情况下，时间复杂度计算式未知数都是用的 N，但是也可以是 M、K、X 等等其他的，如果出现其他字母（非N）的情况情况我们可以这么表示：
如果 M 远大于 N → O(M)
如果 N 远大于 M → O(N)
M 和 N 差不多大 → O(M + N)
实例3：计算 Func4 的时间复杂度
void Func4(int N) { int count = 0; for (int k = 0; k < 100; ++ k) { ++count; } printf("%d\n", count); }
答案：O(1)
解析：基本操作执行了10次，通过推到大N阶的方法，时间复杂度为O(1) 。值得注意的是，
这里的 "1" 是常数次而不是代表算法运行1次。
实例4：计算 BubbleSort 的时间复杂度
void BubbleSort(int* a, int n) { assert(a); for (size_t end = n; end > 0; --end) { int exchange = 0; for (size_t i = 1; i < end; ++i) { if (a[i-1] > a[i]) { Swap(&a[i-1], &a[i]); exchange = 1; } } if (exchange == 0) { break; } } }
O(N^2)
解析：基本操作执行最好N次，最坏执行了(N*(N+1)/2次，通过推导大O阶方法+时间复杂度一般看最坏，时间复杂度为 O(N^2) 。冒泡排序，前一个比后一个大就交换。这两个循环虽然嵌套在一起，但是里面的循环不是n，外面的循环也不是n，而是end，它是在变化的。{ N-1 N-2 N-3 ... 1 } ，所以他是个等差数列。
实例5：计算 BinarySearch 的时间复杂度
int BinarySearch(int* a, int n, int x) { assert(a); int begin = 0; int end = n - 1; while (begin < end) { int mid = begin + ((end-begin) >> 1); if (a[mid] < x) begin = mid + 1; else if (a[mid] > x) end = mid; else return mid; } return -1; }
O(logN)
算法分析中logN没有特殊说明应该是默认2为底,因为以2为底的log函数的相对增长率要大于其他底数情况（如底数为3,4,5……）.作为对时间复杂度的估计,底数为2的O(logN)可以看做是log函数型相对增长率的上界
解析：基本操作执行最好1次，最坏O(logN)次，时间复杂度为O(logN）。
数据结构与算法①(第一章复杂度知识点)(大O渐进表示法)（下）：https://developer.aliyun.com/article/1513303
