数据结构与算法-基本概念
在线学习
https://www.hello-algo.com/chapter_preface/
什么是数据结构与算法
从广义上讲数据结构就是指一组数据的存储结构。算法就是操作数据的一组方法。
从狭义上讲,是指某些著名的数据结构和算法，比如队列、栈、堆、二分查找、动态规划等。这些都是前人智慧的结晶，我们可以直接拿来用。
数据结构和算法是相辅相成的。数据结构是为算法服务的，算法要作用在特定的数据结构之上。 因此，我们无法孤立数据结构来讲算法，也无法孤立算法来讲数据结构。
数据结构和算法是解决 "快"和"省"的问题
算法的执行效率
算法的执行效率，粗略地讲，就是算法代码执行的时间。但是，如何在不运行代码的情况下，用“肉眼”得到一段代码的执行时间呢？
复杂度分析
为什么需要复杂度分析
一个不用具体的测试数据来测试，就可以粗略地估计算法的执行效率的方法
因为往往我们需要测试一段代码或者接口的性能,都需要跑一遍才知道。往往受到环境和数据量影响,比如测试环境4核cpu生产环境8核，数据量测试环境处理几千条,生产环境处理几百万。不同的环境处理结果不同。
时间复杂度
大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度（asymptotic time complexity），简称时间复杂度。
大 O 这种复杂度表示方法只是表示一种变化趋势。我们通常会忽略掉公式中的常量、低阶、系数，只需要记录一个最大阶的量级就可以了
例子1
如：求 1,2,3...n 的累加和
1 int cal(int n) { 2 int sum = 0; 3 int i = 1; 4 for (; i <= n; ++i) { 5 sum = sum + i; 6 } 7 return sum; 8 }
从 CPU 的角度来看，这段代码的每一行都执行着类似的操作：读数据-运算-写数据。尽管每行代码对应的 CPU 执行的个数、执行的时间都不一样，但是，我们这里只是粗略估计，所以可以假设每行代码执行的时间都一样，为 unit_time。在这个假设的基础之上，这段代码的总执行时间是多少呢？
第 2、3 行代码分别需要 1 个 unit_time 的执行时间，第 4、5 行都运行了 n 遍，所以需要 2n*unit_time 的执行时间，所以这段代码总的执行时间就是 (2n+2)*unit_time。可以看出来，所有代码的执行时间 T(n) 与每行代码的执行次数成正比。
例子2
1 int cal(int n) { 2 int sum = 0; 3 int i = 1; 4 int j = 1; 5 for (; i <= n; ++i) { 6 j = 1; 7 for (; j <= n; ++j) { 8 sum = sum + i * j; 9 } 10 } 11 }
第 2、3、4 行代码，每行都需要 1 个 unit_time 的执行时间，第 5、6 行代码循环执行了 n 遍，需要 2n * unit_time 的执行时间，第 7、8 行代码循环执行了 n2遍，所以需要 2n2 * unit_time 的执行时间。所以，整段代码总的执行时间 T(n) = (2n2+2n+3)*unit_time。
尽管我们不知道 unit_time 的具体值，但是通过这两段代码执行时间的推导过程，我们可以得到一个非常重要的规律，那就是，所有代码的执行时间 T(n) 与每行代码的执行次数 f(n) 成正比。
总结
根据例子1和例子2得出总结代码的执行时间 T(n) 与 f(n) 表达式成正比,总结公式就是:
T(n)=O(f(n))
T(n) 它表示代码执行的时间；n 表示数据规模的大小；f(n) 表示每行代码执行的次数总和。因为这是一个公式，所以用 f(n) 来表示。公式中的 O，表示代码的执行时间 T(n) 与 f(n) 表达式成正比
所以，第一个例子中的 T(n) = O(2n+2)，第二个例子中的 T(n) = O(2n2+2n+3)。这就是大 O 时间复杂度表示法。大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度（asymptotic time complexity），简称时间复杂度。
当 n 很大时，你可以把它想象成 10000、100000。而公式中的低阶、常量、系数三部分并不左右增长趋势，所以都可以忽略。我们只需要记录一个最大量级就可以了，如果用大 O 表示法表示刚讲的那两段代码的时间复杂度，就可以记为：T(n) = O(n)； T(n) = O(n2)。
时间复杂度分析方法
关注循环次数多的代码
我们在分析一个算法、一段代码的时间复杂度的时候，也只关注循环执行次数最多的那一段代码就可以了。这段核心代码执行次数的 n 的量级，就是整段要分析代码的时间复杂度。
1 int cal(int n) { 2 int sum = 0; 3 int i = 1; 4 for (; i <= n; ++i) { 5 sum = sum + i; 6 } 7 return sum; 8 }
其中第 2、3 行代码都是常量级的执行时间，与 n 的大小无关，所以对于复杂度并没有影响。循环执行次数最多的是第 4、5 行代码，所以这块代码要重点分析。前面我们也讲过，这两行代码被执行了 n 次，所以总的时间复杂度就是 O(n)。
加法法则
总复杂度等于量级最大的那段代码的复杂度
1 int cal(int n) { 2 int sum_1 = 0; 3 int p = 1; 4 for (; p < 100; ++p) { 5 sum_1 = sum_1 + p; 6 } 7 8 int sum_2 = 0; 9 int q = 1; 10 for (; q < n; ++q) { 11 sum_2 = sum_2 + q; 12 } 13 14 int sum_3 = 0; 15 int i = 1; 16 int j = 1; 17 for (; i <= n; ++i) { 18 j = 1; 19 for (; j <= n; ++j) { 20 sum_3 = sum_3 + i * j; 21 } 22 } 23 24 return sum_1 + sum_2 + sum_3; 25 }
这个代码分为三部分，分别是求 sum_1、sum_2、sum_3。我们可以分别分析每一部分的时间复杂度，然后把它们放到一块儿，再取一个量级最大的作为整段代码的复杂度。
第一段的时间复杂度是多少呢？这段代码循环执行了 100 次，所以是一个常量的执行时间，跟 n 的规模无关。这里要再强调一下，即便这段代码循环 10000 次、100000 次，只要是一个已知的数，跟 n 无关，照样也是常量级的执行时间。
当 n 无限大的时候，就可以忽略。尽管对代码的执行时间会有很大影响，但是回到时间复杂度的概念来说，它表示的是一个算法执行效率与数据规模增长的变化趋势，所以不管常量的执行时间多大，我们都可以忽略掉。因为它本身对增长趋势并没有影响。
那第二段代码和第三段代码的时间复杂度是多少呢？答案是 O(n) 和 O(n2)，
综合这三段代码的时间复杂度，我们取其中最大的量级。所以，整个方法代码的时间复杂度就为 O(n2)。
也就是说：总的时间复杂度就等于量级最大的那段代码的时间复杂度。那我们将这个规律抽象成公式就是：如果 T1(n)=O(f(n))，T2(n)=O(g(n))；那么 T(n)=T1(n)+T2(n)=max(O(f(n)), O(g(n))) =O(max(f(n), g(n))).
乘法法则
嵌套代码的复杂度等于嵌套内外代码复杂度的乘积
1 int cal(int n) { 2 int ret = 0; 3 int i = 1; 4 for (; i < n; ++i) { 5 ret = ret + f(i); 6 } 7 } 8 9 int f(int n) { 10 int sum = 0; 11 int i = 1; 12 for (; i < n; ++i) { 13 sum = sum + i; 14 } 15 return sum; 16 }
我们单独看 cal() 函数。假设 f() 只是一个普通的操作，那第 4～6 行的时间复杂度就是，T1(n) = O(n)。但 f() 函数本身不是一个简单的操作，它的时间复杂度是 T2(n) = O(n)，所以，整个 cal() 函数的时间复杂度就是，T(n) = T1(n) * T2(n) = O(n*n) = O(n2)。
常见的时间复杂度分析
O(1)
首先你必须明确一个概念，O(1) 只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。比如这段代码，即便有 3 行，它的时间复杂度也是 O(1），而不是 O(3)。
int i = 8; int j = 6; int sum = i + j;
只要代码的执行时间不随 n 的增大而增长，这样代码的时间复杂度我们都记作 O(1)。或者说，一般情况下，只要算法中不存在循环语句、递归语句，即使有成千上万行的代码，其时间复杂度也是Ο(1)。
O(logn)和O(nlogn)
O(logn)：对数时间复杂度。当算法的时间复杂度为O(logn)时，算法的运行时间随着输入规模n的增长而增长，但是增长的速度是以对数的形式增长的。例如，二分查找算法的时间复杂度就是O(logn)。这意味着随着输入规模的增大，算法的运行时间以较慢的速度增长。
O(nlogn)：线性对数时间复杂度。当算法的时间复杂度为O(nlogn)时，算法的运行时间随着输入规模n的增长而增长，但是增长的速度是以n乘以logn的形式增长的。例如，归并排序和快速排序算法的时间复杂度都是O(nlogn)。这意味着随着输入规模的增大，算法的运行时间以较快的速度增长，但是仍然比指数级的增长慢。
理解O(logn)和O(nlogn)的时间复杂度可以帮助我们评估算法的效率和性能。通常情况下，O(logn)的算法比O(nlogn)的算法更高效，因为对数级的增长速度比线性对数级的增长速度更慢。但是具体的评估还需要考虑算法的具体实现和问题的特性。
最好、最坏、平均、均摊时间复杂度
例子
因为，要查找的变量 x 可能出现在数组的任意位置。如果数组中第一个元素正好是要查找的变量 x，那就不需要继续遍历剩下的 n-1 个数据了，那时间复杂度就是 O(1)。但如果数组中不存在变量 x，那我们就需要把整个数组都遍历一遍，时间复杂度就成了 O(n)
从数组搜索x数字
// n表示数组array的长度 int find(int[] array, int n, int x) { int i = 0; int pos = -1; for (; i < n; ++i) { if (array[i] == x) pos = i;
break; } return pos; }
最好
搜索的数字在第一个位置
最坏
搜索的数字在末尾,或者不存在
