前言
算法就是定义良好的计算过程，它取一个活一组的值输入，并产生出一个或一组值作为输出。简单来说，算法就是一系列的计算步骤，用来将输入数据转化成输出结果。
一、算法效率
如何去衡量一个算法的好坏？
算法在编写成可执行程序后，运行时消耗时间和空间资源。因此，一般从时间和空间两个维度来衡量，即时间复杂度和空间复杂度。
时间复杂度和空间复杂度
时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行时所需要的额外空间。
在计算机发展的早期，计算机的存储容量很小。所以对复杂度很是在乎。但是计算机行业的迅速发展，计算机存储容量已经达到很高的程度，所以我们并不用特别关注算法的空间复杂度
二、时间复杂度
时间复杂度是指算法在执行过程中，所需要的时间资源和问题规模之间的关系，主要衡量算法的运行效率，用来估算算法在不同规模下的运行时间
时间复杂度用大O的渐进表示法来表示
2.1时间复杂度的计算
算法的时间复杂度是一个函数式T(N)，它定量描述了该算法的运行时间。
实际上，我们计算时间复杂度时，计算主要涉及到以下几个方面
基本操作次数： 时间复杂度的计算通常关注算法中执行的基本操作次数，例如赋值操作、比较操作、算术运算等。通常将这些操作的数量与输入规模相关联。
循环结构： 算法包含循环结构，需要考虑循环的迭代次数以及每次迭代中的基本操作数量。
递归调用： 对于递归算法，需要考虑递归的深度以及每次递归调用的时间复杂度。通常使用递归方程（递归关系式）来表示递归算法的时间复杂度。
分支结构： 如果算法包含分支结构，需要考虑每个分支的执行次数以及分支中的基本操作数量。
输入规模： 时间复杂度的计算通常与输入规模有关。输入规模表示算法操作的数据量或问题的大小，通常用符号n表示。
说白了，算法复杂度其实就是计算基本操作的执行次数
看一个案例，来计算时间复杂度
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;
}
}
这里Func函数基础语句执行次数 T(N)=N^2+2N+10
用大O的渐进表示法表示就成了 O(N^2)
大O的渐进表示法
1 . 时间复杂度的函数式T(N)中，只保留最高阶项，去掉那些低阶项
2 . 如果最高项存在且不是1，则去掉这个项的常数系数
3 . T（N）中如果没有N的相关项，只要常数项，用常数1来取代所有加法常数
2.2、时间复杂度计算实例
2.2.1、示例一
void Func1(int N)
{
int count = 0;
for (int k = 0; k < 2 * N; ++k)
{
++count;
}
int M = 10;
while (M--)
{
++count;
}
printf("%d\n", count);
}Func1函数基本操作次数
T（N）= 2N+10
大O渐进表示法 Func1的时间复杂度为：O(N)
2.2.2、示例二
void Func2(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);
}Func1函数基本操作次数
T（N）= M+N
因为这里无法确定M和N的大小，所以有大O渐进表示法 就为：O(M+N)
2.2.3、示例三
void Func3(int N)
{
int count = 0;
for (int k = 0; k < 100; ++k)
{
++count;
}
printf("%d\n", count);
}Func3函数的基本操作次数
T（N）=100
用大O渐进表示法 表示 O(1)
2.2.4、示例四
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;
}这里计算strchr函数的基本操作次数
如果查找的字符在字符串的第一个位置（靠前的位置）则T（N）= 1
如果查找的字符在字符串最后 则T（N）= N
如果查找的字符在字符串中间位置 则T（N）= N/2
这样用大O渐进表示法就要三种情况
情况一： O(1) 情况二： O(N) 情况三： O(N)
这里我们就会发现，有些算法的时间复杂度存在多种情况
最好情况 ： 任意出入规模的最小运行次数（下界）
最坏情况 ： 任意输入规模的最大运行次数（上界）
平均情况： 任意输入规模的期望运行次数
大O渐进表示法在实际情况中一般关注的是算法的上界，也就是最坏运行情况。
所以这里strchr函数的时间复杂度为：O（N）
2.2.5、示例五
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;
}
}冒泡排序的时间复杂度
如果数组有序为升序，则T(N) = N （最好情况）
如果数组有序为降序，则T(N) = (N*(N+1))/2 （最坏情况）
因此BubbleSort的时间复杂度为 O(N^2)
2.2.6、示例六
void func4(int n)
{
int cnt = 1;
while (cnt < n)
{
cnt *= 2;
}
}Func4函数
n=2，执行次数为1
n=4，执行次数为2
n=16，执行次数为4
当执行次数为x时，n=2^x
所以执行次数 x=
所以时间复杂度为：
这里也可以写成log n
当N接近无穷大时，底数的大小对结果影响不大。因此，一般情况下不管底数为多少都可以省略不写，写成log n
2.2.7、示例七
long long Fac(size_t N)
{
if (0 == N)
return 1;
return Fac(N - 1) * N;
}这里每一次调用Fac函数的时间复杂度为O(1)
而一共有n次递归，所以阶乘递归的时间复杂度为O（N）
三、空间复杂度
空间复杂度也是一个数学表达式，是对一个算法在运行过程中因为算法的需要额外临时开辟的空间
空间复杂度表示程序占用了多少bytes的空间，因为常规情况下每个对象大小 差异不会很大，所以空间复杂度计算的是变量的个数
空间复杂度也使用大O渐进表示法
这里函数运行时所需要的栈空间（存储参数，局部变量。一些寄存器信息等）在编译期间已经确定好了，空间复杂度主要通过函数在运行时显示申请的额外空间来确定
空间复杂度计算
示例一
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额外申请的空间有exchange等有限个局部变量，使用了常数个额外的空间
因此时间复杂度为：O(1）
示例二
long long Fac(size_t N)
{
if (N == 0)
return 1;
return Fac(N - 1) * N;
}Fac递归调用了N次，额外开辟了N个函数栈帧，每个栈帧使用了常数个空间
因此时间复杂度为：O(N)
感谢各位大佬支持并指出问题，
如果本篇内容对你有帮助，可以一键三连支持以下，感谢支持！！！
1419
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
