算法之【时间复杂度】与【空间复杂度】

目录

一、算法

1、算法定义

2、两种算法的比较

3、算法的特性

4、算法设计的要求

二、算法的复杂度

1、时间复杂度

1.1定义

1.2大O的渐近表示法

1.3推导大O阶方法

1.4最坏情况与平均情况

1.5常见的时间复杂度计算示例

常数阶:

线性阶: 

对数阶:

平方阶:

2、空间复杂度


一、算法

1、算法定义

算法就是定义良好的计算过程,它取一个或一组的值为输入,并产生出一个或一组的值作为输出。简单来说算法就是一系列的计算步骤,用来将输入数据转化成输出结果。概括起来就是数据结构是在内存当中存储、管理数据;算法是对各种数据进行处理,怎么处理就看我们自己的需求了。

2、两种算法的比较

现在要求写一个求1+2+3+······+100结果的程序,大多数人会马上写出下面的C语言代码:

#include 
int main()
{
	int i;
	int sum = 0;
	int  n = 100;
	for (i = 1; i <= 100; i++)
	{
		sum += i;
	}
	printf("%d\n", sum);

	return 0;
}

这是最简单的计算机程序之一,它就是一种算法,但这种算法是最高效的吗?

这个时候,我们就得将伟大的数学家高斯的童年故事拿来说一遍。据说18世纪生于德国小村庄的高斯,上小学的一天,课堂很乱,老师就非常生气,于是在放学时,就要求每个学生都计算1+2+···+100的结果,谁先算出来谁先回家。天才当然不会被这样的问题难倒,高斯很快就得出了答案,是5050。老师非常惊讶,因为他自己想必也是通过1+2=3,3+3=6,······4950+100=5050这样算出来的,也算了很久很久。可是,眼前这个少年,一个上小学的孩子,为何可以这么快的得出结果?高斯解释道:

sum = 1 + 2 + 3 + ... + 99 + 100
sum = 100 + 99 + 98 + ... + 2 + 1
2 * sum  = 100 + 101 + 101 +  ... + 101 + 101 (共100个)

所以sum = 5050

用程序实现如下:

#include 
int main()
{
	int sum = 0;
	int n = 100;
	sum = (1 + n) * n / 2;
	printf("%d\n", sum);

	return 0;
}

 高斯的方法相当于一种求等差数列的算法,不仅仅可以用于1加到100,就是加到1千,1万,1亿,也就是瞬间之事。但如果用第一种挨个加的程序,显然计算机要循环1千,1万,1亿次的加法运算。

3、算法的特性

算法具有五个基本特性:输入输出有穷性确定性可行性

算法之【时间复杂度】与【空间复杂度】_第1张图片

输入输出:

算法具有零个或多个输入,至少有一个或多个输出。

有穷性:

指算法在执行有限的步骤之后,自动结束而不会出现无限循环,并且每一个步骤在可接受的时间内完成。

确定性:

算法的每一步骤都具有确定的含义,不会出现二义性。

可行性:

算法的每一步都必须是可行的,也就是说,每一步都能够通过执行有限次数完成。

4、算法设计的要求

好的算法设计有四个要求:正确性可读性健壮性时间效率高和存储量低

算法之【时间复杂度】与【空间复杂度】_第2张图片

正确性:

算法的正确性是指算法至少应该具有输入、输出和加工处理无歧义性,能正确反映问题的需求,能够得到问题的正确答案。 

可读性:

算法设计的另一目的是为了方便阅读、理解和交流。

健壮性:

当输入数据不合法时,算法也能做出相关处理,而不是产生异常或莫名其妙的结果。

时间效率高和存储量低:

时间效率指的是算法的执行时间,执行时间短的算法效率高,执行时间长的效率低;存储量需求指的是算法在执行过程中需要的最大存储间,主要指算法程序运行时所占用的内存或外部硬盘存储空间。

二、算法的复杂度

算法在编写成可执行程序后,运行时需要耗费时间资源和空间(内存)资源。因此衡量一个算法的好坏,一般是从时间和空间两个角度来衡量的,即时间复杂度空间复杂度

时间复杂度主要衡量一个算法的运行快慢,而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算机发展的早期,计算机的存储容量很小,所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展,计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要在特别关注一个算法的空间复杂度。

1、时间复杂度

1.1定义

在计算机科学中,算法的时间复杂度是一个函数,它定量描述了该算法的运行时间。一个算法执行所耗费的时间,从理论上说,是不能算出来的,只有你把你的程序放在机器上跑起来,才能知道。但是我们需要每个算法都上机测试吗?是都可以上机测试,但是这很麻烦,所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例。算法中的基本操作的执行次数,为算法的时间复杂度。即找到某条基本语句与问题规模N之间的数学表达式,就是算出了该算法的时间复杂度。

1.2大O的渐近表示法

我们先来看一段代码,请计算一下Func1中++count语句总共执行了多少次?

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

printf("%d\n", count);
}

Func1 执行的基本操作次数:F(N) = N^2 + 2*N + 10

  • 实际中我们计算时间复杂度时,其实并不一定要计算精确的执行次数,而只需要计算大概执行次数,那么这里我们使用大O的渐进表示法。
  • 大O符号(Big O notation):是用于描述函数渐进行为的数学符号 。

1.3推导大O阶方法

  1. 用常数1取代运行时间中的所有加法常数。
  2. 在修改后的运行次数函数中,只保留最高阶项。
  3. 如果最高阶项存在且其系数不是1,则去除与这个项相乘的系数。

得到的结果就是大O阶。

 上面的代码使用大O渐进法以后,Func1的时间复杂度为:O(N^2)

1.4最坏情况与平均情况

通过上面的代码示例我们会发现大O的渐进表示法去掉了那些对结果影响不大的项,简洁明了的表示出了执行次数。另外有些算法的时间复杂度存在最好、平均和最坏情况:

最坏情况:任意输入规模的最大运行次数(上界)
平均情况:任意输入规模的期望运行次数
最好情况:任意输入规模的最小运行次数(下界)

例如:我们在一个长度为N的数组中查找某个数字:

最好情况:1次找到
最坏情况:N次找到
平均情况:N/2次找到

在实际中一般在没有特殊说明的情况下,关注的都是算法的最坏运行情况,即最坏时间复杂度,所以数组中搜索数据时间复杂度为O(N)。


1.5常见的时间复杂度计算示例

常数阶:
int sum = 0,n = 100;//执行一次
sum = (1 + n) * n / 2;//执行一次
printf("%d\n", sum);//执行一次

这个算法的运行次数函数是f(n) = 3。根据我们推导大O阶的方法,第一步就是把常数项3改为1。在保留最高项阶时发现,它根本没有最高阶项,所以这个算法的时间复杂度为O(1)。

另外,我们试想一下,如果这个算法当中的语句sum = (1 + n) * n / 2有10句,即:

int sum = 0, n = 100;//执行1次
sum = (1 + n) * n / 2;//执行第1次
sum = (1 + n) * n / 2;//执行第2次
sum = (1 + n) * n / 2;//执行第3次
sum = (1 + n) * n / 2;//执行第4次
sum = (1 + n) * n / 2;//执行第5次
sum = (1 + n) * n / 2;//执行第6次
sum = (1 + n) * n / 2;//执行第7次
sum = (1 + n) * n / 2;//执行第8次
sum = (1 + n) * n / 2;//执行第9次
sum = (1 + n) * n / 2;//执行第10次
printf("%d\n", sum);//执行1次

事实上无论n为多少,上面的两段代码就是3次执行和12次执行的差异。这种与问题的大小(n的大小)无关,执行时间恒定的算法,我们称之为具有O(1)的时间复杂度,又叫常数阶。

注意:不管这个常数是多少,我们都记作O(1),而不能是O(3)、O(12)等其它任何数字。

线性阶: 

线性阶的循环结构会复杂很多。要确定某个算法的阶次,我们常常需要确定某个特定语句或某个语句集运行的次数。因此,我们要分析算法的复杂度,关键就是要分析循环结构的运行情况。

int i;
for (i = 0; i < n; i++)
{

}

 上面这段代码,循环体中的代码需要执行n次,所以它的时间复杂度就为O(n)。

对数阶:
int count = 1;
while (count < n)
{
	count = count * 2;
}

上面这段代码,由于每次count乘以2之后,就距离n更近了一分。也就是说,有多少个2相乘后大于n,则会退出循环。由2^x=n得到x=log以2为底的n次方。所以这个循环的时间复杂度为O(logn)。 

平方阶:
int i, j;
for (i = 0; i < n; i++)
{
	for (j = 0; j < n; j++)
	{

	}
}

上面这段代码是一个嵌套循环,它的内层循环时间复杂度为O(n);而对于外层的循环,不过是内部这个时间复杂度为O(n)的语句,再循环n次。所以这段代码的时间复杂度为O(n^2)。

如果外循环的循环次数改为了m,时间复杂度就变为O(m*n)。

int i, j;
for (i = 0; i < n; i++)
{
	for (j = 0; j < m; j++)
	{

	}
}

所以我们可以总结得出,循环的时间复杂度等于循环体的复杂度乘以该循环的运行次数。 


 那么下面这个循环嵌套,它的时间复杂度是多少呢?

int i, j;
for (i = 0; i < n; i++)
{
	for (j = i; j < n; j++)
	{

	}
}

由于当i = 0时,内循环执行了n次,当i  = 1时执行了n-1次,······当i = n - 1时,执行了1次。所以总的执行次数为:

n + (n-1) + (n-2) +···+1 = n(n+1)/2 = n^2/2 + n/2

用我们推导大O阶的方法,第一条,没有加法常数不予考虑;第二条,只保留最高阶项,因此保留n^2/2;第三条,去除与这个项相乘的常数,也就是去除1/2,最终这段代码的时间复杂度为O(n^2)。 


常见的时间复杂度如下表所示:

算法之【时间复杂度】与【空间复杂度】_第3张图片

常用的时间复杂度所耗费的时间从小到大依次是:

O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)

2、空间复杂度

  • 空间复杂度也是一个数学表达式,是一个算法在运行过程中临时占用存储空间大小的量度 。
  • 空间复杂度不是程序占用了多少bytes的空间,因为这个也没太大意义,所以空间复杂度算的是变量的个数。
  • 空间复杂度计算规则基本跟时间复杂度类似,也使用大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;
	}
}

上面这段代码使用了常数个额外空间,所以空间复杂度为 O(1) 。

实例2:

// 计算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;
}

上面这段代码动态开辟了N个空间,空间复杂度为 O(N) 。

实例3:

// 计算阶乘递归Fac的空间复杂度?
long long Fac(size_t N)
{
	if (N == 0)
		return 1;
	return Fac(N - 1) * N;
}

上面这段代码递归调用了N次,开辟了N个栈帧,每个栈帧使用了常数个空间,所以空间复杂度为O(N) 。

你可能感兴趣的:(数据结构,算法,数据结构,时间复杂度,空间复杂度)