程序员必修课—算法效率

如泡似影

已于 2023-11-08 23:00:30 修改

阅读量955

点赞数 28

分类专栏：数据结构文章标签：算法数据结构 c语言 c++

于 2023-11-04 12:57:44 首次发布

本文链接：https://blog.csdn.net/bubble_shadow/article/details/134209687

版权

数据结构专栏收录该内容

13 篇文章 0 订阅

订阅专栏

前言

对于同一个问题，可以有很多种不同的算法，而好的算法能帮助你事半功倍，因此了解影响算法效率的因素，并在日常中有意识的以此来选择较优算法是十分重要的

文章细分了各个小点，可以通过目录速览和跳转

一、算法效率？

算法的效率体现在编写成可执行程序后，程序的运行效率，也就是执行时间短，耗费空间少，这里要注意代码不是越简洁越好，比如函数中常见的方法递归，十分简洁，但非常耗时。因此，我们创造了算法复杂度这个概念来对算法效率进行衡量。

          //递归实现斐波那契数列
long long Fib(int n)
{
   if(N < 3)
      return 1;
   return Fib(N-1) + Fib(N-2);
}

二、算法复杂度

1.时间复杂度

i. 定义

在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。
一个算法所花费的时间与其中语句的执行次数成正比例，算法中的语句的执行次数，为算法的时间复杂度。

ii.计算方法

一般来说，代码自上而下必然执行一次，因此我们计算的是多次执行的语句的运行次数。下面我们通过一个实例来分析。

void Func1(int N)
{
	int count = 0;
	for (int i = 0; i < N; ++i)            //for语句，循环执行 N*N 次
	{
		for (int j = 0; j < N; ++j)
		{
			++count;
		}
	}

	for (int k = 0; k < 2 * N; ++k)          //for语句，循环执行 2*N 次
	{
		++count;
	}
	int M = 10;
	while (M--)                               //while语句，循环执行 10 次
	{
		++count;
	}
	printf("%d\n", count);
}

该段代码中有三个多次执行的语句，因此它们的执行次数，也就是时间复杂度为 $N^2 + 2*N +10$
在实际应用中，我们不必计算的如此准确，而更为重要的是，我们一般不可能将代码一一写出来再评判算法的优劣，而是在大脑构思时就要进行算法（思路）的筛选，因此我们更多时候使用大O的渐进表示法来计算时间复杂度。

iii.大O的渐进表示法

本质：通过去掉对结果影响不大的项来简化计算。
组成：大写字母O + （），括号内为影响语句执行次数的变量关系式或常数1，如O( $N^2$ ), O(M+N), O(1），O（logN）等。使用N来表示未知数是约定俗成的方式，并没有什么特殊含义。
推导方法：极限思想。当N较大或较小时，N的最高次项对结果的影响远大于其他次项，同理N前的系数也是如此，对结果影响不大，故我们进行以下操作。

1. 一个未知数只保留其最高次项，省略其前系数
2. 只有常数时，统一用1表示

语句执行次数不确定时：在实际应用中，比如我们要写一个函数帮助我们查找某组数据中的某个值，有可能只找一次就找到了，这是最好的情况，也有可能要找遍整组数据才能找到，这是最坏的情况，取其平均值就是平均的情况。那我们应该如何计算复杂度呢？时间复杂度是一个比较保守的值，也就是我们要选择最坏的情况，这样做的好处是能使我们有一个预期管理，减少未知性带来的意外影响。

2.空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。
注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因
此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。如计算某个函数的空间复杂度时，不在此函数体内创建的变量（如传参，全局变量等）不算入复杂度。
值得一提的是，在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

3.实例分析

i. 时间复杂度实例

- 实例1 O(M+N)

void Func3(int N, int M)
{
	int count = 0;
	for (int k = 0; k < M; ++k)         //未知数M
	{
		++count;
	}
	for (int k = 0; k < N; ++k)         //未知数N
	{
		++count;
	}
	printf("%d\n", count);
}

//复杂度为 M+N

- 实例2 O(1)

void Func4(int N)           //未知数N
{
 int count = 0;
 for (int k = 0; k < 100; ++ k)    //这里的K有具体数值，要从代码思想上看，
                                   //执行次数为100
 {
 ++count;
 }
 printf("%d\n", count);
}

//本题虽然有未知数N，但该未知数不影响语句的执行次数，故不计入复杂度计算
//复杂度为O(1)

- 实例3 冒泡排序O(N^2)

//冒泡排序
void BubbleSort(int* a, int n)
{
	assert(a);
	for (size_t end = n; end > 0; --end)  //外层循环 未知数end
	{
		int exchange = 0;
		for (size_t i = 1; i < end; ++i)  //内层循环 未知数end-1
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
		}
		if (exchange == 0)
			break;
	}
}
/* 本题需要读者理解基础的冒泡排序思路，小编不再赘述过多
   语句执行次数不确定，最好的情况是第一趟外层循环就可以排序好，
执行次数为N-1（内层循环次数），复杂度为0(N)。
  最坏情况是外层循环走完N次，内层循环次数为N-1 + N-2 + N-3
+...+ 3 + 2 + 1 = N*(N-1)/2 [等差数列求和],复杂度为O(N^2)
*/

- 实例4 二分查找O(logN)

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;
}
/*本题需要读者掌握基本二分查找思想，小编不再过多赘述
  二分查找，最好情况找一次，最坏情况找到只剩一个元素，设找了x次，初始元素个数为N，每找一次/2，
  则一共除了x个2，有N /2/2/.../2 = 1，移项得N = 2^x(2的x次方），两边同时取log2，
  则有log2 N = x，
  因此复杂度写作O(logN),这里的log为log2的简写形式，有些书上写成lgN，但我们不建议这样写，
  会和数学知识混淆
*/

- 实例5 递归O(N)

long long Fac(size_t N)
{
	if (0 == N)
		return 1;

	return Fac(N - 1) * N;
}

在这里插入图片描述
如上图所示，函数递归了N-1次，复杂度为O(N)

- 实例6 递归O(2^N)

long long Fib(size_t N)
{
	if (N < 3)
		return 1;

	return Fib(N - 1) + Fib(N - 2);
}

在这里插入图片描述

如图，每个函数都要执行一次，故复杂度为F(N) = 2^0 + 2^1 + 2^2 + …+2^(N-2),运用数学方法，错位相减求和，F(N) = 2^(N-1) - 1，复杂度为O(2^N)

ii.空间复杂度实例

- 实例1 O(1)

void BubbleSort(int* a, int n)
{
	assert(a);
	for (size_t end = n; end > 0; --end)    //变量end
	{
		int exchange = 0;                  //变量exchange
		for (size_t i = 1; i < end; ++i)   //变量i
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
		}
		if (exchange == 0)
			break;
	}
}
//变量个数为常数个，故空间复杂度为O(1)

- 实例2 单次递归O(N)

long long Fac(size_t N)
{
	if (N == 0)
		return 1;

	return Fac(N - 1) * N;
}

在这里插入图片描述
递归只有在递推完开始回归时才会释放空间，每个递归函数都需要开辟一个空间，故开辟空间个数为N，空间复杂度为O(N).

- 实例3 多次递归O(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的单次递归，多次递归时，也是先一路执行完一个单次递归（蓝色部分）再执行其他的递归函数，当蓝色部分执行完后，为它们开辟的空间也会被释放，这样其他的递归函数可以复用这些空间。
可以理解为如图从左往右一列一列执行，除了第一列需要开辟空间，其余每列都是在复用这一列的空间，故空间复杂度为O(N)