算法时间复杂度
在计算机程序编写前，依据统计方法对算法进行估算，经过总结，我们发现一个高级语言编写的程序程序在计算机上运行所消耗的时间取决于下列因素:
1.算法采用的策略和方案;
⒉编译产生的代码质量;
3.问题的输入规模(所谓的问题输入规模就是输入量的多少);
4.机器执行指令的速度;
由此可见，抛开这些与计算机硬件、软件有关的因素，一个程序的运行时间依赖于算法的好坏和问题的输入规模。
如果算法固定，那么该算法的执行时间就只和问题的输入规模有关系了。
我们研究算法复杂度，侧重的是当输入规模不断增大时，算法的增长量的一个抽象(规律)，而不是精确地定位需要执行多少次，因为如果是这样的话，我们又得考虑回编译期优化等问题，容易主次跌倒。
我们不关心编写程序所用的语言是什么，也不关心这些程序将跑在什么样的计算机上，我们只关心它所实现的算法。
这样，不计那些循环索引的递增和循环终止的条件、变量声明、打印结果等操作，最终在分析程序的运行时间时，最重要的是把程序看做是独立于程序设计语言的算法或一系列步骤。
我们分析一个算法的运行时间，最重要的就是把 核心操作的次数和输入规模 关联起来。
算法时间复杂度分析 T(n)=O(f(n))，大O推导法则
定义∶
在进行算法分析时，语句总的执行次数 T(n)是关于问题规模 n 的函数，进而分析T(n) 随着 n 的变化情况并确定 T(n)的量级。
算法的时间复杂度，就是算法的时间量度，记作:T(n)=O(f(n))。
它表示随着问题规模 n 的增大，算法执行时间的增长率和 f(n) 的增长率相同，称作算法的渐近时间复杂度，简称时间复杂度，其中f(n)是问题规模 n 的某个函数。
在这里，我们需要明确一个事情︰执行次数=执行时间
用大写O来体现算法时间复杂度的记法，我们称之为***大O记法***。一般情况下，随着输入规模 n 的增大，T(n)增长最慢的算法为最优算法。
如果用大O记法表示下面三个个算法的时间复杂度，应该如何表示呢?
算法一：
public static void main(string[ ] args) {
int sum = 0; //执行1次
int n=100; //执行1次
for (int i = 1; i <= n; i++) {
sum += i; //执行了n次
}
system.out.println( "sum=" + sum) ;
}
算法二：
public static void main( string[] args) {
int sum = o; //执行1次
int n=100; //执行1次
for (int i = 1; i <= n; i++) {
sum += i; //执行了n次
}
system.out.println( "sum=" + sum);
}
算法三：
public static void main( string[] args) {
int sum=o; //执行1次
int n=100; //执行1次
for (int i = 1; i <=n ; i++) {
for (int j = 1; j <=n ; j++){
sum+=i; //执行n^2次
}
}
system.out.println( "sum="+sum);
}
如果忽略判断条件的执行次数和输出语句的执行次数，那么当输入规模为n时，以上算法执行的次数分别为:
算法一∶ 3次
算法二 : n+3次
算法三 : n^2+2次
大O推导法则
基于我们对函数渐近增长的分析，推导大O阶的表示法有以下几个规则可以使用∶
1.用常数1取代运行时间中的所有加法常数;
2.在修改后的运行次数中，只保留高阶项;
3.如果最高阶项存在，且常数因子不为1，则去除与这个项相乘的常数;
所以上术算法的大〇记法分别为:
算法一∶ O(1)
算法二 : O(n)
算法三 : O(2^n)
常见大O阶：
线性阶 O(n) ，非嵌套循环
一般含有非嵌套循环涉及线性阶，线性阶就是随着输入规模的扩大，对应计算次数呈直线增长，例如∶
public static void main(string[] args) {
int sum = 0;
int n=100;
for (int i = 1; i <= n; i++) {
sum += i;
system.out.println( "sum=" + sum);
}
}
这段代码，它的循环的时间复杂度为O(n),因为循环体中的代码需要执行n次。
平方阶 O(n^2)，循环双层嵌套
一般嵌套循环属于这种时间复杂度：
public static void main(string[ ] args) {
int sum=0,n=100;
for (int i = 1; i <=n ; i++) {
for (int j = 1; j <=n ; j++){
sum+=i;
}
}
system.out.println(sum);
}
这段代码，n=100，也就是说，外层循环每执行一次，内层循环就执行100次，那总共程序想要从这两个循环中出来，就需要执行100*100次，也就是n的平方次，所以这段代码的时间复杂度是O(n^2)。
立方阶 O(n^3) ，循环三层嵌套
—般三层嵌套循环属于这种时间复杂度：
public static void main(string[ ] args) {
int x=0,n=100;
for (int i = 1; i <=n ; i++) {
for (int j = i; j <=n ; j++) {
for (int j = i; j <=n ; j++) {
X++;
}
}
}
system.out.println(x);
}
这段代码，n=100，也就是说，外层循环每执行一次，中间循环循环就执行100次，中间循环每执行一次，最内层循环需要执行100次，那总共程序想要从这三个循环中出来，就需要执行100100100次，也就是n的立方，所以这段代码的时间复杂度是O(n^3)。
对数阶 O(logn)，涉及指数幂运算
老师说对数莫慌，高中数学，分析程序以程序为主，数学为铺。
int i=1,n=100;
while(i<n){
i=i*2；
}
由于每次*2之后，就距离n更近一步，假设有x个2相乘后大于n，则会退出循环。由于是2^x=n,得到 x=log(2)n,所以这个循环的时间复杂度为O(logn)。
对于对数阶，由于随着输入规模n的增大，不管底数为多少，他们的增长趋势是一样的，所以我们会忽略底数。
常数阶 O(1)，不涉及循环操作，不随着输入规模的增长而增加操作次数
一般不涉及循环操作的都是常数阶，因为它不会随着输入规模n的增长而增加操作次数。例如︰
public static void main(string[ ] args) {
int n=10o;
int i=n+2;
system.out.println(i);
}
上述代码，不管输入规模n是多少，都执行2次，根据大O推导法则，常数用1来替换，所以上述代码的时间复杂度为O(1)。
下表是对常见时间复杂度的一个总结:
| 描述 | 增长的数量级 | 说明 | 举例 |
|---|---|---|---|
| 常数级别 | 1 | 普通语句 | 将两数相加 |
| 对数级别 | logn | 二分策略 | 二分查找 |
| 线性级别 | n | 循环 | 找出最大元素 |
| 线性对数级别 | NlogN | 分治思想 | 归并排序 |
| 平方级别 | n^2 | 双层循环 | 检查所有元素对 |
| 立方级别 | n^3 | 三层循环 | 检查所有三元组 |
| 指数级别 | 2^n | 穷举查找 | 检查所有子集 |
他们的复杂程度从低到高依次为∶
O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n3)
根据前面分析，我们会发现，从平方阶开始，随着输入规模的增大，时间成本 会急剧增大，
所以，我们的算法，尽可能的追求的是 常数阶O(1),对数阶O(logn)，线性阶O(n),线性对数O(nlogn) 这几种时间复杂度而如果发现算法的时间复杂度为平方阶、立方阶或者更复杂的，那我们可以认为这种算法是不可取的，需要优化。
函数调用的时间复杂度分析
之前，我们分析的都是单个函数内，算法代码的时间复杂度，接下来我们分析函数调用过程中时间复杂度。
案列一：
public static void main(string[] args) {
int n=100;
for (int i = o; i < n; i++) {
show( i);
}
}
private static void show( int i) {
system.out.println(i);
}
在main方法中，有一个for循环，循环体调用了show方法，由于show方法内部只执行了一行代码，所以show方法的时间复杂度为O(1),那main方法的时间复杂度就是O(n)。
案例二：
public static void main(string[] args) {
int n=100;
for (int i = 0; i < n; i++) {
show(i);
}
}
private static void show(int i) {
for (int j = 0; j < i; i++) {
system.out.println(i);}
}
在main方法中，有一个for循环，循环体调用了show方法，由于show方法内部也有一个for循环，所以show方法的时间复杂度为O(n)那main方法的时间复杂度为O(n^2)。
案例三：
public static void main(string[ ] args) {
int n=100;
show(n); //执行次数为n^2
for (int i = o; i < n; it) { //执行次数为n^2
show(i);
for (int i = o; i < n; it+) {
for (int j = o; j < n; jt+)i
system.out .printin(j);
}
}
}
private static void show( int i) {
for (int j = 0; j < i; i++) { //执行次数为n
system.out.println(i);
}
}
在show方法中，有一个for循环，所以show方法的时间复杂度为O(n)。
在main方法中，show(n)这行代码内部执行的次数为 n；
for循环内调用了show方法，所以其执行次数为 n^2；
第二个嵌套for循环内只执行了一行代码,所以其执行次数为 n^2；
那么main方法总执行次数为n+ n^2 + n^2简化为 2n^2+n 。
根据大O推导规则，去掉n保留最高阶项，并去掉最高阶项的常数因子2，
所以最终main方法的时间复杂度为O(n^2)
最坏情况，除非特别指定，我们提到的运行时间都指的是最坏情况下的运行时间
假如有一个需求，有一个存储了n个随机数字的数组，请从中查找出指定的数字。
最好情况∶查找的第一个数字就是期望的数字，那么算法的时间复杂度为O(1)
最坏情况∶查找的最后一个数字，才是期望的数字，那么算法的时间复杂度为O(n)
平均情况: 任何数字查找的平均成本是O(n/2)
最坏情况是一种保证，在应用中，这是一种最基本的保障，即使在最坏情况下，也能够正常提供服务，
所以，除非特别指定，我们提到的运行时间都指的是最坏情况下的运行时间。
算法空间复杂度
计算机的软硬件都经历了一个比较漫长的演变史，作为为运算提供环境的内存，更是如此，
从早些时候的512k,经历了1M，2M ，4M…等，发展到现在的8G，甚至16G和32G。
所以早期时候，算法在运行过程中对内存的占用情况也是一个经常需要考虑的问题。
那么 我们可以用算法的空间复杂度来描述算法对内存的占用。
常见内存占用：
1.Java为例，基本数据类型定义存储，内存占用：
2.计算机访问内存的方式都是一次一个字节
3.—个引用（机器地址）需要8个字节表示︰
//date这个变量需要占用8个字节来表示
Date date = new Date();
4.创建一个对象，比如new Date()，除了Date对象内部存储的数据(例如年月日等信息)占用的内存，
该对象本身也有内存开销，每个对象的自身开销是16个字节，用来保存对象的头信息。
5.—般内存的使用，如果不够8个字节，都会被自动填充为8字节:
public class A{
public int a = 1;
}
/*通过new A()创建一个对象的内存占用如下:
1.整型成员变量a占用4个字节;
2.对象本身占用16个字节;
那么创建该对象总共需要20个字节，但由于不是以8位单位，会自动填充为24个字节
*/
算法的空间复杂度分析 S(n) = O(f(n))
了解了java语言为例的内存最基本的机制，就能够有效帮助我们估计大量程序的内存使用情况。
算法的空间复杂度计算公式记作: S(n) = O(f(n))
其中n为输入规模，f(n) 为语句关于n所占存储空间的函数。
案例:对指定的数组元素进行反转,并返回反转的内容。
解法一：
public static int[ ] reverse1(int[ ] arr){
int n=arr.length;//申请4个字节
int temp;//申请4个字节
for(int start=0,end=n-1;start <= end ; start++,end--){
temp=arr[start];
arr[start]=arr[end];arr[end ]=temp;
}
return arr;
}
解法二：
public static int[ ] reverse2(int[] arr){
int n=arr.length;//申请4个字节
int[] temp=new int[n];//申请n*4个字节+数组自身头信息开销24个字节
for (int i = n-1; i >=o; i--) {
temp[n-1-i]=arr[i];
}
return temp;
}
对比分析：
忽略 判断条件占用的内存，我们得出的内存占用情况如下:
算法一︰
不管传入的数组大小为多少，始终额外申请4+4=8个字节;
算法二︰
4+4n+24=4n+28;
根据大O推导法则，算法一的空间复杂度为O(1)，算法二的空间复杂度为O(n)。
所以从空间占用的角度讲，算法一 要 优于算法二。
由于java中有内存垃圾回收机制，并且jvm对程序的内存占用也有优化（例如即时编译），我们无法精确的评估一个java程序的内存占用情况，但是了解了java的基本内存占用，使我们可以对java程序的内存占用情况进行估算。
由于现在的计算机设备内存一般都比较大，基本上个人计算机都是4G起步，大的可以达到32G，
所以内存占用一般情况下并不是我们算法的瓶颈，普通情况下直接说复杂度，默认为算法的时间复杂度。
但是，如果你做的程序是嵌入式开发，尤其是一些传感器设备上的内置程序，由于这些设备的内存很小，一般为几kb，这个时候对算法的空间复杂度就有要求了，但是一般做java开发的，基本上都是服务器开发，一般不存在这样的问题。
扫一扫
759
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
