目录
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）。
实例6：计算递归版斐波那契数 Fib 的时间复杂度
递归算法：递归次数 * 每次递归调用次数
long long Fib(size_t N) {
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}答案：O(2^N)
解析：通过计算分析发现基本操作递归了2^N次，时间复杂度为O(2^N) 。
使用大O渐进法表示结果如下：
2.3空间复杂度的概念
空间复杂度的定义：空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度。 空间复杂度并不是程序占用了多少bytes的空间，前面在介绍算法复杂度的时候就提到了如今我们已经不再关注 "空间" ，所以关注程序占用多少byte的空间是没有太大意义的。空间复杂度算的是变量的个数！ 此外，空间复杂度的计算规则基本和时间复杂度没有什么区别，同样也使用 大O渐进表示法。
注意事项：函数运行时所需要的栈空间（即存储参数、局部变量和一些寄存器信息等）在编译期间就已经确定好了，因此空间复杂度主要是通过函数在运行的时候显式申请的额外空间来决定。
实例1：计算 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(1) 。
实例2：计算 Fibonacci 的空间复杂度
// 返回斐波那契数列的前n项
long long* Fibonacci(size_t n)
{
if(n==0)
return NULL;
long long * fibArray = (long long *)malloc((n+1) * sizeof(long long));
fibArray[0] = 0;
fibArray[1] = 1;
for (int i = 2; i <= n ; ++i)
{
fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
}
return fibArray;
}解析：malloc 动态开辟了N个空间，空间复杂度为 O(N)
实例3：计算递归版阶乘 Fac 的空间复杂度
long long Fac(size_t N)
{
if (0 == N)
return 1;
return Fac(N - 1) * N;
}答案：O(N)
解析：递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N) 。
2.4常见复杂度对比
大O对比图：
3.笔试选择题
（答案放最后）
3.1下列有关大O表示法的说法错误的是
A.大O表示法只是对程序执行时间的一个估算
B.大O表示法只保留最高阶项
C.大O表示法会保留一个系数来更准确的表示复杂度
D.大O表示法一般表示的是算法最差的运行时间
3.2分析以下函数的时间复杂度
void fun(int n)
{
int i=l;
while(i<=n)
i=i*2;
}A.O(n)
B.O(n^2)
C.O(nlogn)
D.O(logn)
3.3分析以下程序的时间复杂度
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
a[i][j]=i*j;A.O(n)
B.O(n^2)
C.O(nlogn)
D.O(logn)
3.4下面算法的时间复杂度是（ ）
int f ( unsigned int n )
{
if (n == 0 || n==1)
return 1;
else
return n * f(n-1);
}A.O(n)
B.O(n^2)
C.O(nlogn)
D.O(logn)
3.5给定一个整数sum，从有N个有序元素的数组中寻找元素a，b，使得a+b的结果最接近sum，最快的平均时间复杂度是（ ）
A.O(n)
B.O(n^2)
C.O(nlogn)
D.O(logn)
3.6分析以下函数的空间复杂度（ ）
int** fun(int n)
{
int** s = (int**)malloc(n * sizeof(int*));
while (n--)
s[n] = (int*)malloc(n * sizeof(int));
return s;
}A.O(n)
B.O(n^2)
C.O( 1 )
D.O(nlogn)
3.7如果一个函数的内部中只定义了一个二维数组a[3][6]，请问这个函数的空间复杂度为（ ）
A.O(n)
B.O(n^2)
C.O( 1 )
D.O(m*n)
3.8设某算法的递推公式是T(n)=T(n-1)+n，T(0)=1，则求该算法中第n项的时间复杂度为（）
A.O(n)
B.O(n^2)
C.O(nlogn)
D.O(logn)
3.9（答案）
1答案：C
解析：大O是一个渐进表示法，不会去表示精确的次数，cpu的运算速度很快，估计精确的没有意义。
2答案：D
解析: 此函数有一个循环，但是循环没有被执行n次，i每次都是2倍进行递增，所以循环只会被执行log2(n)次。
3答案：B
解析：程序有两次循环，每个循环都有n次操作，所以时间复杂度为n^2
4答案：A
解析：此函数会被递归调用n - 1次，每次操作都是一次，所以时间复杂度为n
5答案：A
解析：此题目中，数组元素有序，所以a,b两个数可以分别从开始和结尾处开始搜，
根据首尾元素的和是否大于sum,决定搜索的移动，整个数组被搜索一遍，就可以得到结果，所以最好时间复杂度为n
6答案：B
解析：此处开辟的是一个二维数组，数组有n行，每行分别有1,2,3,...n列，所以是n(n + 1)/2个元素空间，空间复杂度为n^2
7答案：C
解析：函数内部数组的大小是固定的，不论函数运行多少次，所需空间都是固定大小的，因此空间复杂度为O(1)
8答案: A
解析：
T(n)
=T(n-1)+n
=T(n-2)+(n-1)+n
=T(n-3)+(n-2)+(n-1)+n
...
=T(0)+1+2+...+(n-2)+(n-1)+n
=1+1+2+...+(n-2)+(n-1)+n
从递推公式中可以看到，第n项的值需要从n-1开始递归，一直递归到0次结束，共递归了n-1次
所以时间复杂度为n
本篇完。(附下篇对应OJ链接)
下一篇更新这一篇的相关力扣OJ。
（穿越回来贴个链接）
3403
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
