算法的时间复杂度和空间复杂度（c语言讲解）

算法的复杂度

1、时间复杂度

定义：在计算机科学中，算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运行时间。

这个T(N)函数式计算了程序的执行次数，执行次数就可以代表程序时间效率的优劣。比如解决⼀个问题的算法a程序T(N) = N，算法b程序T(N) = N^2，那么算法a的效率⼀定优于算法b。

以下面程序为例子：

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

Func1 执行的基本操作次数：

T (N) = N2 + 2 ∗ N + 10

• N = 10 T (N) = 130
• N = 100 T (N) = 10210
• N = 1000 T(N) = 1002010

通过对N取值分析，对结果影响最大的⼀项是 N²。易知当N不断变大时常数和低阶项对结果的影响很小，所以我们只需要计算程序能代表增长量级的大概执行次数，复杂度的表示通常使用大O的渐进表示法。

1.1大O的渐进表示法

1.1.1推导规则

• 时间复杂度函数式T(N)，只保留最高阶项，去掉低阶项，因为当N不断变大时，低阶项对结果的影响越来越小，当N无穷大的时候，就可以忽略不计了
• 如果最高阶项存在且不是1，则去除这个项目的常数系数，因为当N不断变大，这个系数对结果的影响也越来越小，当N无穷大时可忽略不计
• T(N)中如果没有N相关的项目，只有常数项，用常数1取代所有加法常数

通过以上规则可以得出上文中的代码的时间复杂度时：O(N²)

1.1.2计算演示

示例1：

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

T (N) = 2N + 10，因此时间复杂度为O(N)

示例2：

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

T(N)=M + N，因此时间复杂度为：O(N)

示例3：

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

T (N) = 100，因此时间复杂度为： O(1)

示例4：

char * strchr ( char* str, int character)
{
	char* p_begin = s;
	while (*p_begin != character)
	{
	if (*p_begin == '\0')
		return NULL;
		p_begin++;
	}
	return p_begin;
}

这个函数需要分情况来讨论：

（1）若查找的字符在字符串的第一个位置，则T(N)=1；

（2）若查找的字符在字符串的最后一个位置，则T(N)=N；

（3）若查找的字符在字符串中间位置，则T(N)=$\frac{N}{2}$；

因此，strchr函数的时间复杂度有以下几种情况：

• 最好情况：O(1)
• 最坏情况：O(N)
• 平均情况：O(N)

示例5： 计算冒泡排序的时间复杂度

void BubbleSort(int* a, int n)
{
	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）若数组有序，则T(N)=N （这里注意，由于当数组本来就是排好序的，所以第二层的for循环就只用循环一遍，所以执行的次数应该仍然是N而不是N²）

（2）若数组有序且为降序，则T(N)=$\frac{N\ast (N+1)}{2}$

因此：BubbleSort的时间复杂度取最差情况为： O(N²)

示例6

void func5(int n)
{
	int a = 1;
	while (a < n)
	{
		a *= 2;
	}
}

假设执行次数为x，则2^x=n

所以执行次数为：x= log n

因此func5函数的时间复杂度取最差情况为O(log₂n)

注：当n接近无穷⼤时，底数的大小对结果影响不大。因此，一般情况下不管底数是多少都可以省略不 写，即可以表示为 log n

示例7

long long func6(size_t N){
    if(N == 0)
        return 1;
    return func6(N-1)*N;
}//阶乘

调用一次func6函数的时间复杂度为O(1)，在这个程序中，存在n次递归调用func6函数

因此阶乘递归的时间复杂度为： O(N)

2、空间复杂度

空间复杂度也是⼀个数学表达式，是一个算法在运行过程中因为算法的需要额外临时开辟的空间。空间复杂度算的是变量的个数，也是用大O渐进表示法

2.1计算演示

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

函数栈帧已经在编译期间确定好了，著需要关注函数在运行时额外申请的空间

上述代码示例中申请了exchange局部变量，使用常数个额外空间

因此空间复杂度为O(1)

示例2

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

func递归调用了N次，额外开辟了N个函数栈帧， 每个栈帧使用了常数个空间

因此空间复杂度为： O(N)

函数栈帧已经在编译期间确定好了，著需要关注函数在运行时额外申请的空间

上述代码示例中申请了exchange局部变量，使用常数个额外空间

因此空间复杂度为O(1)

示例2

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

func递归调用了N次，额外开辟了N个函数栈帧， 每个栈帧使用了常数个空间

因此空间复杂度为： O(N)