算法复杂度详解与优化
目录
一、了解数据结构和算法
1、数据结构
数据结构(Data Structure)是计算机存储、组织数据的⽅式，指相互之间存在⼀种或多种特定关系的数 据元素的集合。没有⼀种单⼀的数据结构对所有⽤途都有⽤，所以我们要学各式各样的数据结构， 如：线性表、树、图、哈希等。
2、算法
算法:就是定义良好的计算过程，他取⼀个或⼀组的值为输⼊，并产⽣出⼀个或⼀组值作为输出。简单来说算法就是⼀系列的计算步骤，⽤来将输⼊数据转化成输出结果。
二、复杂度
1.复杂度的概念：
算法在编写成可执⾏程序后，运⾏时需要耗费时间资源和空间(内存)资源 。因此衡量⼀个算法的好 坏，⼀般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。
时间复杂度主要衡量⼀个算法的运⾏快慢，⽽空间复杂度主要衡量⼀个算法运⾏所需要的额外空间。在计算机发展的早期，计算机的存储容量很⼩。所以对空间复杂度很是在乎。但是经过计算机⾏业的迅速发展，计算机的存储容量已经达到了很⾼的程度。所以我们如今已经不需要再特别关注⼀个算法的空间复杂度。
2.时间复杂度：
算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运⾏时间。
时间复杂度是衡量程序的时间效率，有时候时间复杂度特别高的时候，我们无法快速的完成这个程序，这就需要我们来降时间复杂度。
首先给大家说一下影响时间复杂度的方面：
1. 因为程序运⾏时间和编译环境和运⾏机器的配置都有关系，⽐如同⼀个算法程序，⽤⼀个⽼编译器进⾏编译和新编译器编译，在同样机器下运⾏时间不同。2. 同⼀个算法程序，⽤⼀个⽼低配置机器和新⾼配置机器，运⾏时间也不同。3. 并且时间只能程序写好后测试，不能写程序前通过理论思想计算评估。
上面这些点都会影响时间复杂度，但是影响最大的还是程序的执行的时间。
程序的执行时间 = 二进制指令运行时间 + 循环次数
几乎时间都一样的(常量)
实际中我们计算时间复杂度时，计算的也不是程序的精确的执⾏次数，精确执⾏次数计算起来还是很⿇烦的(不同的⼀句程序代码，编译出的指令条数都是不⼀样的)，计算出精确的执⾏次数意义也不⼤，因为我们计算时间复杂度只是想⽐较算法程序的增⻓量级，也就是当N不断变⼤时T(N)的差别，上⾯我们已经看到了当N不断变⼤时常数和低阶项对结果的影响很⼩，所以我们只需要计算程序能代表增⻓量级的⼤概执⾏次数，复杂度的表⽰通常使⽤⼤O的渐进表⽰法。
⼤O符号（Big O notation）是⽤于描述函数渐进⾏为的数学符号。O（n）
推导⼤O阶规则
1. 时间复杂度函数式T(N)中，只保留最⾼阶项，去掉那些低阶项，因为当N不断变⼤时，低阶项对结果影响越来越⼩，当N⽆穷⼤时，就可以忽略不计了。
2. 如果最⾼阶项存在且不是1，则去除这个项⽬的常数系数，因为当N不断变⼤，这个系数对结果影响越来越⼩，当N⽆穷⼤时，就可以忽略不计了。
3. T(N)中如果没有N相关的项⽬，只有常数项，⽤常数1取代所有加法常数。
例题1：常见计算时间复杂度
// 请计算⼀下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;
}
}这里的T(N)原本为N^2+2N+10，根据上面的规则1得出T(N)=N^2.
所以时间复杂度：O(N^2)
剩下的两个规则都比较好理解，就是在系数不为1的情况下将系数化为1即可，只有常数项的时候时间复杂度就为O(1)。
下面有一个比较复杂的情况：
例题2：复杂度情况不唯一
// 计算strchr的时间复杂度？
const char * strchr ( const char* str, int character)
{
const char* p_begin = s;
while (*p_begin != character)
{
if (*p_begin == '\0')
return NULL;
p_begin++;
}
return p_begin;
}这里我们算出来它的时间复杂度根据情况改变，不唯一：
1）若要查找的字符在字符串第⼀个位置，则： T (N) = 1
2）若要查找的字符在字符串最后的⼀个位置， 则： T (N) = N
3）若要查找的字符在字符串中间位置，则： T (N) = N/2
因此：strchr的时间复杂度分为：
最好情况： O(1)
最坏情况： O(N)
平均情况： O(N)
通过上⾯我们会发现，有些算法的时间复杂度存在最好、平均和最坏情况。
最坏情况：任意输⼊规模的最⼤运⾏次数(上界)
平均情况：任意输⼊规模的期望运⾏次数
最好情况：任意输⼊规模的最⼩运⾏次数(下界)
⼤O的渐进表⽰法在实际中⼀般情况关注的是算法的上界，也就是最坏运⾏情况。
例题3：时间复杂度为O(logn)的形式
void func5(int n)
{
int cnt = 1;
while (cnt < n)
{
cnt *= 2;
}
}首先先分析一下：
当n=2时，执⾏次数为1当n=4时，执⾏次数为2当n=16时，执⾏次数为4假设执⾏次数为 x ，则 2* x = n因此执⾏次数： x = log 2 n(这个2是下标，电脑上打不出来 qaq)
所以该算法的时间复杂度为O((log n)
当n接近⽆穷⼤时，底数的⼤⼩对结果影响不⼤。因此，⼀般情况下不管底数是多少都可以省略不 写，即可以表⽰为 log n。
例题4：递归函数的时间复杂度：
// 计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N)
{
if(0 == N)
return 1;
return Fac(N-1)*N;
}递归算法的时间复杂度 = 单次递归的时间复杂度 * 递归次数
调⽤⼀次Fac函数的时间复杂度为 O(1) ，⽽在Fac函数中，存在n次递归调⽤Fac函数，
因此：阶乘递归的时间复杂度为： O(n)
三、空间复杂度
空间复杂度也是⼀个数学表达式，是对⼀个算法在运⾏过程中因为算法的需要额外临时开辟的空间。空间复杂度不是程序占⽤了多少bytes的空间，因为常规情况每个对象⼤⼩差异不会很⼤，所以空间复杂度算的是变量的个数。
空间复杂度计算规则基本跟实践复杂度类似，也使⽤⼤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;
}
}BubbleSort额外申请的空间有end，exchange，i 这3个局部变量，使⽤了常数个额外空间
因此空间复杂度为 O(1).
示例2：计算递归函数的空间复杂度
那递归函数的空间复杂度呢，来看下面这个示例：
// 计算阶乘递归Fac的空间复杂度？
long long Fac(size_t N)
{
if(N == 0)
return 1;
return Fac(N-1)*N;
}Fac递归调⽤了N次，额外开辟了N个函数栈帧，每个栈帧使⽤了常数个空间
因此空间复杂度为： O(N)
递归算法的空间复杂度 = 单次递归的空间复杂度 * 递归次数
当然，除递归外还有空间复杂度为n的情况，比如：
int* arr = (int *)malloc(N * sizeof(int));用malloc开辟动态内存，它的空间复杂度就为O(N)
四、复杂度算法题
题目描述：给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
我们正常写代码应该是这样：
1、时间复杂度为：O(n^2) 的解法
void rotate(int* nums, int numsSize, int k) {
while(k--)
{
int temp=nums[numsSize-1];
for(int i=numsSize-1;i>0;i--)
{
nums[i]=nums[i-1];
}
nums[0]=temp;
}
}这个代码的时间复杂度为：O(n^2)
但是如果k足够大的话，这个代码就运行的太慢了，从而超过时间限制。
所以我们要用另一种时间复杂度更小的算法来解决这道题，我下面给大家分享三个解题方法：
2、时间复杂度为：O(n) 的解法
申请新数组空间，先将后k个数据放到新数组中，再将剩下的数据挪到新数组中。
void rotate(int* nums, int numsSize, int k) {
int tmep[numsSize];
for(int i=0;i<numsSize;i++)
{
tmep[(i+k)%numsSize]=nums[i];
}
for(int i=0;i<numsSize;i++)
{
nums[i]=tmep[i];
}
}3、时间复杂度为：O(1) 的解法
创建函数，使用3次逆置
前n-k个逆置： 4 3 2 1 5 6 7后k个逆置 ：4 3 2 1 7 6 5整体逆置 ： 5 6 7 1 2 3 4
void reverse(int* nums, int left, int right)
{
while(left<right)
{
int temp=nums[left];
nums[left]=nums[right];
nums[right]=temp;
left++;
right--;
}
}
void rotate(int* nums, int numsSize, int k) {
k=k%numsSize;
reverse(nums,0,numsSize-k-1);
reverse(nums,numsSize-k,numsSize-1);
reverse(nums,0,numsSize-1);
}以上就是我分享的有关复杂度的知识，欢迎大家在评论区讨论和补充！也期待大家的点赞关注！
扫一扫
455
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
