目录
1.算法效率
1.1算法复杂度
算法在编写成可执行程序后,运行需要耗费时间资源和空间(内存)资源。一般从时间和空间两个维度来衡量一个算法的好坏。
2.时间复杂度
2.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;
}
printf("%d\n", count);
}
Func1执行的基本操作次数:
F(N)=N^2+2*N+10
实际中我们不要求计算精确的执行次数,只需要大概执行次数,此时就需要使用大O的渐进表示法。
2.2大O的渐进表示法
大O的使用方法:
1.用常数1取代运行时间中的所有加法常数
2.只保留最高阶项,去掉那些对结果不大的项
3.如果最高阶项存在且不是1,则去除与这个项目的常数项
此时Func1的时间复杂度为:
O(N^2)
2.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);
}
答案:
F()=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);
}
答案:
F()=100
O(1)
案例4:
// 计算strchr的时间复杂度?
const char * strchr ( const char * str, int character );
答案:
基本操作执行最好是1次,最坏是N次,时间复杂度一般看最坏。
O(N)
3.空间复杂度
3.1空间复杂度的概念
空间复杂度也是一个数学表达式,是对一个算法在运行的过程中临时占用存储空间大小的量度。
函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了,因此空间复杂度主要通过函数在运行时候申请的额外空间来确定。
3.2常见空间复杂度的计算案例
案例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;
}
答案:
O(N)
案例3:
// 计算阶乘递归Fac的空间复杂度?
long long Fac(size_t N)
{
if(N == 0)
return 1;
return Fac(N-1)*N;
}
答案:
递归调用了N次,开辟了N个栈帧,每个栈帧使用了常数个空间
O(N)
4.常见复杂度对比
由小到大依次排序:
O(1) < O(log) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(n!) < O(N^n)