算法的基本概念和效率度量

1. 算法的基本概念

算法（Algorithm）是对特定问题求解步骤的一种描述，它是指令的有限序列，其中的每条指令表示一个或多个操作。此外，一个算法还具有下列5个重要特性：

1. 有穷性。一个算法必须总在执行有穷步之后结束，且每一步都可在有穷时间内完成。
2. 确定性。算法中每条指令必须有确切的含义，对于相同的输入只能得出相同的输出。
3. 可行性。算法中描述的操作都可以通过已经实现的基本运算执行有限次来实现。
4. 输入。一个算法有零个或多个输入，这些输入取自于某个特定的对象的集合。
5. 输出。一个算法有一个或多个输出，这些输出是与输入有着某种特定关系的量。

通常，设计一个“好”的算法应考虑达到以下目标：

1. 正确性。算法应能够正确地解决求解问题。
2. 可读性。算法应具有良好的可读性，以帮助人们理解。
3. 健壮性。输入非法数据时，算法能适当地做出反应或进行处理，而不会产生莫名其妙的输出结果。
4. 效率与低存储量需求。效率是指算法执行的时间，存储量需求是指算法执行过程中所需要的最大存储空间，这两者都与问题的规模有关。

2. 算法效率的度量

算法效率的度量是通过时间复杂度和空间复杂度来描述的。

2.1 时间复杂度

一个语句的频度是指该语句在算法中被重复执行的次数。算法中所有语句的频度之和记为T(n)，它是该算法问题规模n的函数，时间复杂度主要分析T(n)的数量级。算法中基本运算（最深层循环内的语句）的频度与T(n)同数量级，因此通常采用算法中基本运算的频度f(n)来分析算法的时间复杂度（取f(n)中随n增长最快的项，将其系数置为1作为时间复杂度的度量）。因此，算法的时间复杂度记为

T(n) = O(f(n))

式中，О的含义是T(n)的数量级，其严格的数学定义是：若T(n)和f(n)是定义在正整数集合上的两个函数，则存在正常数C和n0，使得当n ≥ n0时，都满足0 ≤ T(n) ≤ Cf(n)。

算法的时间复杂度不仅依赖于问题的规模n，也取决于待输入数据的性质（如输入数据元素的初始状态）。例如，在数组A[0...n-1]中，查找给定值k的算法大致如下：

i = n-1;
while(i >= 0 && A[i] != k)
i--;
return i;

该算法中语句3（基本运算）的频度不仅与问题规模n有关，而且与输入实例中A的各元素的取值及k的取值有关：

1. 若A中没有与k相等的元素，则语句3的频度f(n) = n。
2. 若A的最后一个元素等于k，则语句3的频度f(n)是常数0。

1. 最坏时间复杂度是指在最坏情况下，算法的时间复杂度。
2. 平均时间复杂度是指所有可能输入实例在等概率出现的情况下，算法的期望运行时间。
3. 最好时间复杂度是指在最好情况下，算法的时间复杂度。

一般总是考虑在最坏情况下的时间复杂度，以保证算法的运行时间不会比它更长。在分析一个程序的时间复杂性时，有以下两条规则：

1. 加法规则 T(n) = T1(n) + T2(n) = O(f(n)) + O(g(n)) = O(max(f(n), g(n)))
2. 乘法规则 T(n) = T1(n) × T2(n) = O(f(n)) × O(g(n)) = O(f(n) × g(n))

常见的渐近时间复杂度为

例题1

void Func(int N)
{
	int count = 0;
	for (int k = 0; k < 2 * N; ++k)
	{
		++count;
	}
	int M = 10;
	while (M--)
	{
		++count;
	}
	printf("%d\n", count);
}

for循环执行了2N次，每次的时间复杂度为O(1)，所以时间复杂度为O(N)。

例题2

void Func(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);
}

第一个for循环执行了M次，每次的时间复杂度为O(1)，第二个for循环执行了N次，每次的时间复杂度为O(1)，所以时间复杂度为O(M + N)。

例题3

void Func(int N)
{
	int count = 0;
	for (int k = 0; k < 100; ++k)
	{
		++count;
	}
	printf("%d\n", count);
}

循环次数与问题规模N无关，执行了常数次，所以时间复杂度为O(1)。

例题4

const char* strchr(const char* str, int character)
{
	while (*str)
	{
		if (*str == character)
			return str;
		else
			str++;
	}
}

最好时间复杂度：O(1)，字符串第一个字符就是指定字符。

最坏时间复杂度：O(n)，字符串最后一个字符是指定字符。

平均时间复杂度：O(n)，假设给定字符在第i个位置的概率均为1 / n，平均比较次数为：

1/n * (1+2+...+n) = 1/n * n(n+1)/2 = (n+1)/2，所以时间复杂度为O(n)。

例题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;
	}
}

最好时间复杂度：O(n)，待排序文件初始是正序的，只需进行一趟冒泡排序，做n - 1次关键词比较，无记录交换。

最坏时间复杂度：O()，待排序文件初始是逆序的，需要进行n - 1趟冒泡排序，第i趟做n - i次关键词比较，执行n - i次记录交换，此时，总的关键词比较次数和记录交换次数均为：

n-1 + n-2 + ... + 1 = (n-1)*n/2，所以时间复杂度为O()。

例题6

int BinarySearch(int* a, int n, int x)
{
	assert(a);
	int begin = 0;
	int end = n - 1;
	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;
}

最好时间复杂度：O(1)，表中间的数就是要查找的数。

最坏时间复杂度：O(n)，二分查找算法每次循环，区间都缩小一半，缩小到区间只有一个记录结束循环。假设循环了x次，则

n/2/2/2/... = 1（除以了x个2）    -->        -->     ，简写成logn，所以时间复杂度为O(logn)。

例题7

long long Fac(size_t N)
{
	if (1 == N)
		return 1;
	return Fac(N - 1) * N;
}

Fac(n)

     ↓

Fac(n-1)

     ↓

Fac(n-2)

     ↓

    ...

     ↓

Fac(1)

递归了n次，每次递归基本语句执行1次，所以时间复杂度为O(n)。

例题8

long long Fib(size_t N)
{
	if (N < 3)
		return 1;
	return Fib(N - 1) + Fib(N - 2);
}

Fib(N)

↙↘

Fib(N-1)                    Fib(N-2)

↙↘                         ↙↘

Fib(N-2)  Fib(N-3)      Fib(N-3)  Fib(N-4)

↙↘       ↙↘             ↙↘       ↙↘

...

...

 ↙↘          

                                                                                                   Fib(3)        Fib(2)

                                                                                      ↙↘                    

                                                                                             Fib(2)  Fib(1)             

...

...

                ↙↘

      Fib(3)        Fib(2)

      ↙↘

Fib(2)  Fib(1)

最右边的分支先完成递归，最左边的分支最后完成递归。近似认为树有n - 1层，递归次数：

，所以时间复杂度为O()。

2.2 空间复杂度

算法的空间复杂度S(n)定义为该算法所耗费的存储空间，它是问题规模n的函数。记为

S(n) = O(g(n))

一个程序在执行时除需要存储空间来存放本身所用的指令、常数、变量和输入数据外，还需要一些对数据进行操作的工作单元和存储一些为实现计算所需信息的辅助空间。若输入数据所占空间只取决于问题本身，和算法无关，则只需分析除输入和程序之外的额外空间。

算法原地工作是指算法所需的辅助空间为常量，即O(1)。

计算以下算法的空间复杂度：

例题1

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;
	}
}

只额外创建了end、exchange、i三个变量（重复创建同一个变量，算一个），所以空间复杂度为O(1)。

例题2

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;
}

动态开辟了n + 1个空间，所以空间复杂度为O(n)。

例题3

long long Fac(size_t N)
{
	if (N == 1)
		return 1;
	return Fac(N - 1) * N;
}

递归了N次，开辟了N个栈帧，每个栈帧使用了常数个空间，所以空间复杂度为O(N)。