1,算法效率
(1)算法的复杂度
算法在编写成可执行程序后,运行时需要耗费时间资源和空间(内存)资源 。因此衡量一个算法的好坏,一般 是从时间和空间两个维度来衡量的,即时间复杂度和空间复杂度。
时间复杂度主要衡量一个算法的运行快慢,而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算 机发展的早期,计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展,计 算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度
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);
}
应为 F(N) = N^2 + 2*N + 10
N = 10 F(N) = 130
N = 100 F(N) = 10210
N = 1000 F(N) = 1002010
实际中我们计算时间复杂度时,我们其实并不一定要计算精确的执行次数,而只需要大概执行次数,那么这 里我们使用大O的渐进表示法。
(2)大O的渐进表示法
大O符号(Big O notation):是用于描述函数渐进行为的数学符号。
推导大O阶方法:
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中,只保留最高阶项。
3、如果最高阶项存在且不是1,则去除与这个项目相乘的常数。得到的结果就是大O阶。
使用大O的渐进表示法以后,Func1的时间复杂度为:O(N^2)
N = 10 F(N) = 100
N = 100 F(N) = 10000
N = 1000 F(N) = 1000000
通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项,简洁明了的表示出了执行次数。
另外有些算法的时间复杂度存在最好、平均和最坏情况:
最坏情况:任意输入规模的最大运行次数(上界)
平均情况:任意输入规模的期望运行次数
最好情况:任意输入规模的最小运行次数(下界)
例如:在一个长度为N数组中搜索一个数据x
最好情况:1次找到
最坏情况:N次找到
平均情况:N/2次找到
在实际中一般情况关注的是算法的最坏运行情况,所以数组中搜索数据时间复杂度为O(N)
(3)举例
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);
}
F(N) = 2*N + 10 --------------> O(N)
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) O(max(M,N))
如果M远大于N,O(M)
如果N远大于M,O(N)
3)例三
// 计算Func4的时间复杂度?
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++ k)
{
++count;
}
printf("%d\n", count);
}
O(1) 代表常数次
(4)常见复杂度对比
一般算法常见的复杂度如下:
(5)复杂度练习题
1)消失的数字
面试题 17.04. 消失的数字 - 力扣(LeetCode)
数组nums
包含从0
到n
的所有整数,但其中缺了一个。请编写代码找出那个缺失的整数。你有办法在O(n)时间内完成吗?
思路一
先排序,再依次查找,如果下一个值不等于前一个+1,下一个值就是消失的数字
如果冒泡排序
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;
}
}
N-1 + N-2 + N-3 + ... 2 + 1
即N*(N-1)/2
-->O(N^2)
故不符合 O(n)
思路二
求和0-N,再依次减去数组中的值 ,剩下的值为消失的值
这种为O(N)
缺陷;N太大存在溢出风险
int missingNumber(int* nums, int numsSize)
{
int N = numsSize;
int ret = (0+N)*(N+1)/2; //等差数列求和公式
for(int i = 0;i < numsSize;++i)
{
ret -=nums[i];
}
return ret;
}
思路三
异或
相同的值异或==0
0和非0异或 == 非0
异或具有交换律
故可以新增数组值为0-N,新数组与原数组的值异或,结果即为消失的值
int missingNumber(int* nums, int numsSize)
{
//对原数组异或
int N = numsSize;
int x = 0;
for(int i = 0; i< numsSize; ++i)
{
x ^= nums[i];
}
//对0-N异或
for(int j = 0; j <= N; ++j)
{
x ^= j;
}
return x;
}
2)旋转数组
给定一个整数数组 nums
,将数组中的元素向右轮转 k
个位置,其中 k
是非负数。
真实的旋转次数为 k%=N
时间复杂度:O(K*N) F(N) = (N-1)*(N-1)
最好情况 k%N == 0
最坏情况 k%N == N-1 -----> O(N^2)
思路一
思路二
void reverse(int* a,int left,int right)
{
while(left < right)
{
int tmp = a[left];
a[left] = a[right];
a[right] = tmp;
++left;
--right;
}
}
void rotate(int* nums, int numsSize, int k)
{
k %= numsSize;
reverse(nums,0,numsSize-k-1);
reverse(nums,numsSize-k,numsSize-1);
reverse(nums,0,numsSize-1);
}
(6)更复杂的时间复杂度
1)例一
void func(int n)
{
int x = 0;
for (int i = 1; i < n; i *= 2)
{
++x;
}
printf("%d\n", x);
}
1*2*2*2*2......*2 = N
假设循环走x次,就是x个2相乘
即2^x = N x = log2 N
时间复杂度: O(log N)
2)例二
// 计算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;
}
二分查找 N N/2 N/4 N/8 ......... 1
情况最坏:
N/2/2/2........../2 = 1
查找了多少次,就是处理多少2
假设查找x次 2^x = N 即 x = log2 N
3)例三
// 计算阶乘递归Fac的时间复杂度?
long long Fac(size_t N)
{
if(0 == N)
return 1;
return Fac(N-1)*N;
}
Fac(N)--------->Fac(N-1)------------>Fac(N-2)....................------->Fac(1)----------->Fac(0)
N+1次
即O(N)
4)例四
// 计算斐波那契递归Fib的时间复杂度?
long long Fib(size_t N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}
为等比数列
累计递归调用次数为 2^0 = 2^1 = ...+ 2^(N-2)
即 2^(N-1)-1 可以用等比数列求和公式或者错位相减法
故O(2^N)
此代码不符合实际
可以优化为
unsigned long long Fib(size_t N)
{
unsigned long long f1 = 1;
unsigned long long f2 = 1;
unsigned long long f3 = 0;
for (size_t i = 3; i <= N; i++)
{
f3 = f1 + f2;
f1 = f2;
f2 = f3;
}
return f3;
}