程序员必修课—算法效率

---

前言

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

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

---

一、算法效率？

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

          //递归实现斐波那契数列
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\ast 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)

总结

本文介绍了算法效率以及影响其的两大因素时间复杂度和空间复杂度。它们拥有一个共同的计算方法大O的渐进表示法，小编通过阐述和实例分析的方式帮助读者了解大O的渐进表示法的基本用法，其中函数递归和多未知数的情况比较复杂，要想真正熟练运用，还需要读者多练习，多思考。