目录
一.算法效率
二.大O渐进表示法
三.时间复杂度
常见的时间复杂度：
时间复杂度计算练习：
四.空间复杂度
常见的空间复杂度：
空间复杂度计算练习：
一.算法效率
追求算法效率：
- 找到问题解法：算法需要在规定的输入范围内，可靠地求得问题的正确解。
- 寻求最优解法：同一个问题可能存在多种解法，我们希望找到尽可能高效的算法。
在能够解决问题的前提下，算法效率已成为衡量算法优劣的主要评价指标，它包括以下两个维度。
- 时间效率：算法运行速度的快慢。
- 空间效率：算法占用内存空间的大小。
简而言之，我们的目标是设计“既快又省”的数据结构与算法。而有效地评估算法效率至关重要，因为只有这样我们才能将各种算法进行对比，从而指导算法设计与优化过程。
效率评估方法主要分为两种：实际测试、理论估算。
在实际测试中我们的代码对于每一种不同的机器会受到其硬件设备的影响，并且对于精确计算算法的时间显然是不合适的，因此我们想到了一种估算方法：大O渐进表示法。
二.大O渐进表示法
大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。
推导大O阶方法：
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。
三.时间复杂度
时间复杂度分析统计的不是算法运行时间，而是算法运行时间随着数据量变大时的增长趋势。
// 算法 A 的时间复杂度：常数阶
void algorithm_A(int n) {
printf("%d", 0);
}
// 算法 B 的时间复杂度：线性阶
void algorithm_B(int n) {
for (int i = 0; i < n; i++) {
printf("%d", 0);
}
}
// 算法 C 的时间复杂度：常数阶
void algorithm_C(int n) {
for (int i = 0; i < 1000000; i++) {
printf("%d", 0);
}
}
- 算法
A只有 1 个打印操作，算法运行时间不随着 n 增大而增长。我们称此算法的时间复杂度为“常数阶”。 - 算法
B中的打印操作需要循环 n 次，算法运行时间随着 n 增大呈线性增长。此算法的时间复杂度被称为“线性阶”。 - 算法
C中的打印操作需要循环 1000000 次，虽然运行时间很长，但它与输入数据大小 n 无关。因此C的时间复杂度和A相同，仍为“常数阶”。
常见的时间复杂度：
时间复杂度计算练习：
// 计算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);
}时间复杂度为：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);
}因为M和N都是未知数因此时间复杂度为： O(M+N)
// 计算Func4的时间复杂度？
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++ k)
{
++count;
}
printf("%d\n", count);
}常数阶，时间复杂度为：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;
}
}冒泡排序思想是每一趟比较相邻两两数字的大小来决定是否交换
第一趟两两比较 , n-1次之后每一趟依次比较n-2次，n-3,n-4.....1 T(N)={[1+(N-1)]*(N-1)}/2 ，最高项为N^2,时间复杂度为O(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的次方为时间复杂度，实则错误。
时间复杂度不能看循环来确定，一定是根据思想来计算时间复杂度。
left和end在整个快排思想中，实际次数一共走了n次，时间复杂度应为O(N)
// 计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N)
{
if(0 == N)
return 1;
return Fac(N-1)*N;
}每次递归调用都会将参数N减小1，直到N等于0或1为止。因此，总共需要进行N次递归调用。由于每次递归调用的计算量是常数级别的，所以总的时间复杂度是O(N)。
// 计算斐波那契递归Fib的时间复杂度？
long long Fib(size_t N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}通过计算分析发现基本操作递归了2^N次，时间复杂度为O(2^N)。
四.空间复杂度
空间复杂度用于衡量算法占用内存空间随着数据量变大时的增长趋势。
空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度 。
空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。
注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。
常见的空间复杂度：
空间复杂度计算练习：
// 计算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;
}
}实例1使用了常数个额外空间，所以空间复杂度为 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;
}实例2动态开辟了N个空间，空间复杂度为 O(N)
// 计算阶乘递归Fac的空间复杂度？
long long Fac(size_t N)
{
if(N == 0)
return 1;
return Fac(N-1)*N;
}实例3递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)
感谢支持！
