目录
大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。
什么是数据结构
内存中储存管理数据的结构，叫做数据结构
数据结构与数据库的区别？
本质都是管理数据，数据结构是在内存中存储管理数据，数据库是在磁盘中存储管理数据
什么是算法
算法是对数据按照某种要求进行处理的方法
数据结构和算法的关系就是相辅相成的
衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。
时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间
什么是时间复杂度？
在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。
但因为不同的硬件性能不同，所以无法确定他的执行需要的时间。
所以规定，算法中的基本操作的执行次数，为算法的时间复杂度。
// 请计算一下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;
}
}他一共需要跑多少次呢，仔细阅读后可得
F(N)=N*N+2N+10 这样的式子我们叫做准确的时间复杂度函数式
函数式计算的算法运行准确次数。
但是当我们计算时，准确的次数其实是没太多大的意义，不方便我们进行比较，我们就用了一种渐进表示法大O，来进行估算
大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。
推导大O阶方法：
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。
时间复杂度一定是最坏的情况
来看这个式子：F(N)=N*N+2N+10
如果N是100，那么就是10210
如果N是1000，那么就是1002010
……
也就是说当N越大，他的末尾那一点就显得不那么重要，我这个式子对结果影响最大的还是N*N这个式子。后面的几乎可以忽略不记了
所以我们可以简化这个表达式为O(N^2)
我们再来看一个式子：
// 计算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);
}准确的时间复杂度F(N)=2*N+10
所以时间复杂度为：O(N)
再看看这个时间复杂度是多少？
// 计算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);
}因为你不知道N和M谁大谁小，所以这个时间复杂度是O(N+M)
如果有人跟你说N远大于M，那么这个时间复杂度就是O(N)
如果有人跟你说M远大于N，那么这个时间复杂度就是O(M)
如果有人跟你说N与M一样大，那么这个时间复杂度无论O(N)还是O(M)都可以
再来看这个
// 计算Func4的时间复杂度？
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++ k)
{
++count;
}
printf("%d\n", count);
}这题的时间复杂度就是O(1)
这个“1”不是表示一次，而是表示常数次
再来看这个
// 计算strchr的时间复杂度？
const char * strchr ( const char * str, int character );strchr是查找一个字符的函数
对于这个函数，其实根据我们输入的内容，我们查找的效率是截然不同的。
有些算法的时间复杂度存在最好、平均和最坏情况：
最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)
时间复杂度都是取最坏的情况
这道题最坏的情况，其实就是我找不到的时候。
时间复杂度为O(N)
接下来看看这道题：
// 计算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)吗？因为是两层循环？绝对是错的。
算时间复杂度绝对不能去数循环，一定要看算法思想来进行计算。
他的准确时间复杂度是F(N)=N-1+N-2+N-3+...+2+1 这样一个等差数列，用等差公式计算而得为N*(N-1)/2
所以时间复杂度是O(N^2)。
最好的情况呢其实是O(N)
我们来看一个比较有难度的
// 计算BinarySearch的时间复杂度？
int BinarySearch(int* a, int n, int x)
{
assert(a);
int begin = 0;
int end = n-1;
// [begin, end]：begin和end是左闭右闭区间，因此有=号
while (begin <= end)
{
int mid = begin + ((end-begin)>>1);
if (a[mid] < x)
begin = mid+1;
else if (a[mid] > x)
end = mid-1;
else
return mid;
}
return -1;
}二分查找的时间复杂度是多少？
最好的情况是O(1)
最坏的情况是找不到或者只剩一个数了才找到
他每次找都是找中间的值，每次都是折2
我们逆着来看，1*2*2*2*......一直乘下去，结果得到了我原来的那一完整的数组N
我这个数组最多被叠多少次呢？
N/2/2/2...... 当区间只剩下1个数的时候，我就不用继续找下去了
折半了多少次，我就除以了多少个2，假设折半查找了x个2
2^X=N，X=log以2为底，N的对数
所以时间复杂度为
1.计算时间复杂度，不是说有多少条语句，他是指一个大概，计算的是计算执行次数。一个执行次数不一定是一条语句，可能是多条，但他一定是常数条。
2.在文本中不方便写对数，但log以2为底，N的对数经常出现，所以我们经常简写成O(logN)
如果是3为底，4为底，该怎么写就怎么写，不简写。
有些书籍或网络资料会简写成lgN，其实是不正确的，因为它默认是以10为底的，容易误导，所以看到这种的都认为以2为底的就行
O(N) VS O(logN)
O(N) O(logN)
假如N是1000 1000 10
假如N是1000万 1000W 20
假如N是14亿 14亿 31
......
所以我们可以知道，logN的效率非常的高，二分查找算法也非常的厉害
我们再来看一道题，消失的数字
数组nums包含从0到n的所有整数，但其中缺了一个。请编写代码找出那个缺失的整数。你有办法在O(n)时间内完成吗？
示例 1：
输入：[3,0,1]
输出：2
思路一：开辟额外的数组
用malloc一个0-N+1这样大的 新的数组，把数组里的值全部赋值为-1，再把所有的值全部赋值进和他值相同的下标的位置，再遍历数组，数组值为-1的下标，就是他缺失的地方，类似于一种映射的思路
思路二：异或
用一个X=0的数，来跟现在所有的数异或一次，然后再跟0-N的数来异或一次，最后的结果就是缺失的那个数
思路三：排序+二分查找
思路四：求和公式计算，把0-N的数加起来，再把数组里所有数减去即可
再来看这道题时间复杂度是多少？
// 计算阶乘递归Fac的空间复杂度？
long long Fac(size_t N)
{
if(N == 0)
return 1;
return Fac(N-1)*N;
}
他一共需要调用N+1次，每次里面都是常数词，所有时间复杂度是O(N)
那这个呢？
// 计算斐波那契递归Fib的时间复杂度？
long long Fib(size_t N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}
他的时间复杂度是多少呢？其实是2^N次方次
我这两个算法我们如何评估呢？
O(N^2)与O(N)的差别大不大
非常巨大，如果我们同样给40，交给两个算法进行运算。斐波那契并不能及时的跑出来，他的计算次数已经达到了指数爆炸的级别。所以说用斐波那契的递归的写法，在实际中并没有任何的价值，所以要把递归写成循环的写法
递归改循环后，时间复杂度就是O(N)，瞬间便能搞定。
当函数栈帧建立得过多时，就容易造成栈溢出而崩溃
空间复杂度
算法的效率是由时间复杂度和空间复杂度来衡量的，空间复杂度是什么呢？
空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度
空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。
空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。
注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。
按照我的理解而言，简单来说就是指：我在实现里自己创的变量，和函数调用自己创的栈帧空间，都属于。
我们来看这道题：
// 计算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)。因为他算的是因为我需要实现这个算法所额外开辟的空间，一共大概有三个，end exchange i ，所以是O(1)
注意：空间是不累计的，但时间会累计
我们再来看这道题：
// 计算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;
}他的空间复杂度是O(N)
再来看看这道题
// 计算阶乘递归Fac的空间复杂度？
long long Fac(size_t N)
{
if(N == 0)
return 1;
return Fac(N-1)*N;
}
他的空间复杂度是O(N)
*斐波那契数的空间复杂度是多少？
// 计算斐波那契递归Fib的空间复杂度？
long long Fib(size_t N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}是O(2^N)吗？如果输入的值是20，是2的20次方，那早就栈溢出了，所以说2^N是不可能的。
实际上是O(N)，为什么呢？
因为时间是累计的，空间是不累计的，可以重复利用
每次调用时，往回走销毁，往回走销毁，每次调用时都是用的同一块空间，最多也就用了常数个N个栈帧
由此可见，栈帧里的空间是可以重复利用的
轮转数组
给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
示例 1:
输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]进阶：
- 尽可能想出更多的解决方案，至少有 三种 不同的方法可以解决这个问题。
- 你可以使用空间复杂度为
O(1),时间复杂度为O(N)的 原地 算法解决这个问题吗？
解法1：
把最后一个数保存起来，然后整体后挪，再把7放到前面去，然后用循环遍历K次足矣。
这种解法，空间复杂度是O(1)，时间复杂度是O(N)吗？
最坏的情况是K=7，旋转七次就又回来了。所以到N-1的时候情况是最坏的，所以此时的时间复杂度是O(N^2)。
所以达不到要求
法二：用空间换时间
开辟一个新的数组，把后K个元素开始，放到新的数组的前面的位置，然后把剩下的放到新的数组的后面，再拷贝回去。
这样的解法，时间复杂度是O(N),空间复杂度却是O(N)了。
法三：
这样的话，就不需要开辟额外的空间了。这样的方法难以想到，更像是一种规律。
216
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
