目录
一、算法
1、算法定义
算法就是定义良好的计算过程,它取一个或一组的值为输入,并产生出一个或一组的值作为输出。简单来说算法就是一系列的计算步骤,用来将输入数据转化成输出结果。概括起来就是数据结构是在内存当中存储、管理数据;算法是对各种数据进行处理,怎么处理就看我们自己的需求了。
2、两种算法的比较
现在要求写一个求1+2+3+······+100结果的程序,大多数人会马上写出下面的C语言代码:
cpp
#include <stdio.h>
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
用程序实现如下:
cpp
#include <stdio.h>
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、算法的特性
算法具有五个基本特性:输入 、输出 、有穷性、确定性和可行性。
🍂输入输出:
算法具有零个或多个输入,至少有一个或多个输出。
🍂有穷性:
指算法在执行有限的步骤之后,自动结束而不会出现无限循环,并且每一个步骤在可接受的时间内完成。
🍂确定性:
算法的每一步骤都具有确定的含义,不会出现二义性。
🍂可行性:
算法的每一步都必须是可行的,也就是说,每一步都能够通过执行有限次数完成。
4、算法设计的要求
好的算法设计有四个要求:正确性、可读性、健壮性、时间效率高和存储量低。
🌻正确性:
算法的正确性是指算法至少应该具有输入、输出和加工处理无歧义性,能正确反映问题的需求,能够得到问题的正确答案。
🌻可读性:
算法设计的另一目的是为了方便阅读、理解和交流。
🌻健壮性:
当输入数据不合法时,算法也能做出相关处理,而不是产生异常或莫名其妙的结果。
🌻时间效率高和存储量低:
时间效率指的是算法的执行时间,执行时间短的算法效率高,执行时间长的效率低;存储量需求指的是算法在执行过程中需要的最大存储间,主要指算法程序运行时所占用的内存或外部硬盘存储空间。
二、算法的复杂度
算法在编写成可执行程序后,运行时需要耗费时间资源和空间(内存)资源。因此衡量一个算法的好坏,一般是从时间和空间两个角度来衡量的,即时间复杂度和空间复杂度。
时间复杂度主要衡量一个算法的运行快慢,而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算机发展的早期,计算机的存储容量很小,所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展,计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要在特别关注一个算法的空间复杂度。
1、时间复杂度
1.1定义
在计算机科学中,算法的时间复杂度是一个函数 ,它定量描述了该算法的运行时间。一个算法执行所耗费的时间,从理论上说,是不能算出来的,只有你把你的程序放在机器上跑起来,才能知道。但是我们需要每个算法都上机测试吗?是都可以上机测试,但是这很麻烦,所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例。**算法中的基本操作的执行次数,为算法的时间复杂度。**即找到某条基本语句与问题规模N之间的数学表达式,就是算出了该算法的时间复杂度。
1.2大O的渐近表示法
我们先来看一段代码,请计算一下Func1中++count语句总共执行了多少次?
cpp
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,则去除与这个项相乘的系数。
得到的结果就是大O阶。
🎈上面的代码使用大O渐进法以后,Func1的时间复杂度为:O(N^2)
1.4最坏情况与平均情况
通过上面的代码示例我们会发现大O的渐进表示法去掉了那些对结果影响不大的项,简洁明了的表示出了执行次数。另外有些算法的时间复杂度存在最好、平均和最坏情况:
🍁最坏情况:任意输入规模的最大运行次数(上界)
🍁平均情况:任意输入规模的期望运行次数
🍁最好情况:任意输入规模的最小运行次数(下界)
例如:我们在一个长度为N的数组中查找某个数字:
🍁最好情况:1次找到
🍁最坏情况:N次找到
🍁平均情况:N/2次找到
在实际中一般在没有特殊说明的情况下,关注的都是算法的最坏运行情况,即最坏时间复杂度,所以数组中搜索数据时间复杂度为O(N)。
1.5常见的时间复杂度计算示例
🍂常数阶:
cpp
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句,即:
cpp
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)等其它任何数字。
🍂线性阶:
线性阶的循环结构会复杂很多。要确定某个算法的阶次,我们常常需要确定某个特定语句或某个语句集运行的次数。因此,我们要分析算法的复杂度,关键就是要分析循环结构的运行情况。
cpp
int i;
for (i = 0; i < n; i++)
{
}
上面这段代码,循环体中的代码需要执行n次,所以它的时间复杂度就为O(n)。
🍂对数阶:
cpp
int count = 1;
while (count < n)
{
count = count * 2;
}
上面这段代码,由于每次count乘以2之后,就距离n更近了一分。也就是说,有多少个2相乘后大于n,则会退出循环。由2^x=n得到x=log以2为底的n次方。所以这个循环的时间复杂度为O(logn)。
🍂平方阶:
cpp
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)。
cpp
int i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < m; j++)
{
}
}
🌲所以我们可以总结得出,循环的时间复杂度等于循环体的复杂度乘以该循环的运行次数。
那么下面这个循环嵌套,它的时间复杂度是多少呢?
cpp
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次。所以总的执行次数为:
cppn + (n-1) + (n-2) +···+1 = n(n+1)/2 = n^2/2 + n/2
用我们推导大O阶的方法,第一条,没有加法常数不予考虑;第二条,只保留最高阶项,因此保留n^2/2;第三条,去除与这个项相乘的常数,也就是去除1/2,最终这段代码的时间复杂度为O(n^2)。
🍒常见的时间复杂度如下表所示:
🍒常用的时间复杂度所耗费的时间从小到大依次是:
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:
cpp
// 计算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:
cpp
// 计算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:
cpp
// 计算阶乘递归Fac的空间复杂度?
long long Fac(size_t N)
{
if (N == 0)
return 1;
return Fac(N - 1) * N;
}
上面这段代码递归调用了N次,开辟了N个栈帧,每个栈帧使用了常数个空间,所以空间复杂度为O(N) 。