前言
算法对于开发人员是非常重要的，我们从常见的算法看起，比如排序算法，排序算法有好几种实现方法，最简单的嵌套两个for循环进行排序，进阶点就可以用 冒泡排序，最终的结果是一样的，但是过程是不一样的，简单点说第一个要比第二个更加的耗费资源和时间，因此，作为程序员，掌握一些比较高级的算法，算法是什么？经常听到这个算法的时间和空间比较复杂，这个时间和空间是啥意思？复杂度的分析
算法就是描述解决问题的方法。
说到算法我们经常会看到时间复杂度和空间复杂度，本章就是学习和理解这个两个东西。
目录
1.复杂度的分析
衡量不同算法的优劣，主要还是根据算法所占的空间和时间两个维度去考虑，既不消耗最多的时间，也不占用最多的空间，就需要从中去寻找一个平衡点，使得代码更加完美。
2.时间维度
是指执行当前算法所消耗的时间，我们通常用时间复杂度来描述。算法执行时间需通过依据该算法编制的程序在计算机上运行时所消耗的时间来度量。而度量一个程序的执行时间通常有两种方法。
2.1.事后统计法
这种方法可行，但不是一个好的方法。该方法有两个缺陷：一是要想对设计的算法的运行性能进行评测，必须先依据算法编制相应的程序并实际运行；二是所得时间的统计量依赖于计算机的硬件、软件等环境因素，有时容易掩盖算法本身的优势。
2.2.事前分析估算的方法
因事后统计方法更多的依赖于计算机的硬件、软件等环境因素，有时容易掩盖算法本身的优劣。因此人们常常采用事前分析估算的方法。
在编写程序前，依据统计方法对算法进行估算。一个用高级语言编写的程序在计算机上运行时所消耗的时间取决于下列因素：
- 算法采用的策略、方法；
- 编译产生的代码质量；
- 问题的输入规模；
- 机器执行指令的速度。
一个算法是由控制结构（顺序、分支和循环3种）和原操作（指固有数据类型的操作）构成的，则算法时间取决于两者的综合效果。为了便于比较同一个问题的不同算法，通常的做法是，从算法中选取一种对于所研究的问题（或算法类型）来说是基本操作的原操作，以该基本操作的重复执行的次数作为算法的时间量度。
2.3.时间复杂度
2.3.1.时间频度
一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
2.3.2.时间复杂度
在刚才提到的时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度概念。 一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T(n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=Ｏ(f(n)),称Ｏ(f(n))（其中f(n) 表示每行代码执行次数之和，而 O 表示正比例关系）为算法的渐进时间复杂度，简称时间复杂度。
2.4.大O表示法
像前面用O( )来体现算法时间复杂度的记法，我们称之为大O表示法。
算法复杂度可以从最理想情况、平均情况和最坏情况三个角度来评估，由于平均情况大多和最坏情况持平，而且评估最坏情况也可以避免后顾之忧，因此一般情况下，我们设计算法时都要直接估算最坏情况的复杂度。
看一个例子
for(i=1; i<=n; ++i)
{
j = i;
j++;
}通过「 大O符号表示法 」，这段代码的时间复杂度为：O(n) ，为什么呢?
在 大O符号表示法中，时间复杂度的公式是： T(n) = O( f(n) )，其中f(n) 表示每行代码执行次数之和，而 O 表示正比例关系，这个公式的全称是：算法的渐进时间复杂度。
我们继续看上面的例子，假设每行代码的执行时间都是一样的，我们用 1颗粒时间 来表示，那么这个例子的第一行耗时是1个颗粒时间，第三行的执行时间是 n个颗粒时间，第四行的执行时间也是 n个颗粒时间（第二行和第五行是符号，暂时忽略），那么总时间就是 1颗粒时间 + n颗粒时间 + n颗粒时间 ，即 (1+2n)个颗粒时间，即： T(n) = (1+2n)*颗粒时间，从这个结果可以看出，这个算法的耗时是随着n的变化而变化，因此，我们可以简化的将这个算法的时间复杂度表示为：T(n) = O(n)
为什么可以这么去简化呢，因为大O符号表示法并不是用于来真实代表算法的执行时间的，它是用来表示代码执行时间的增长变化趋势的。
所以上面的例子中，如果n无限大的时候，T(n) = time(1+2n)中的常量1就没有意义了，倍数2也意义不大。因此直接简化为T(n) = O(n) 就可以了。
2.5.常见的时间复杂度量级
推导大O阶
推导大O阶，我们可以按照如下的规则来进行推导，得到的结果就是大O表示法：
1.用常数1来取代运行时间中所有加法常数。
2.修改后的运行次数函数中，只保留最高阶项
3.如果最高阶项存在且不是1，则去除与这个项相乘的常数。
3.时间复杂度的阶
- 常数阶O(1)
- 对数阶O(log平方N)
- 线性阶O(n)
- 线性对数阶O(nlogN)
- 平方阶O(n2)
- 立方阶O(n3)
- K次方阶O(nk)
- 指数阶(2n)
上面从上至下依次的时间复杂度越来越大，执行的效率越来越低。
3.1.常数阶O(1)
int sum = 0,n = 100; //执行一次
sum = (1+n)*n/2; //执行一次
System.out.println (sum); //执行一次 上面算法的运行的次数的函数为f(n)=3，根据推导大O阶的规则1，我们需要将常数3改为1，则这个算法的时间复杂度为O(1)。如果sum = （1+n）*n/2这条语句再执行10遍，因为这与问题大小n的值并没有关系，所以这个算法的时间复杂度仍旧是O(1)，不管sum，n，等于多少程序执行一次，即 T(sum) = O(1)，即 T(n) = O(1)，我们可以称之为常数阶。
3.2. 对数阶O(logn)
int num=1;
while(num<n){
num=num*2;
//时间复杂度为O(1)的算法
...
}上面算法循环体中，随着num每次都乘以2，就会越来越接近n，，当num不小于n时就会退出循环。假设循环的次数为X，则由2^x=n得出x=log₂n，因此得出这个算法的时间复杂度为O(logn)。
3.3.线性阶O(n)
for (int i = 1; i < n; i++) {
System.out.println("线性阶：" + n);
}
n的值为多少，程序就运行多少次，类似函数 y = f(x)，即 T(n) = O(n)
3.4.线性对数阶O(nlog平方n)
for (int m = 1; m <= n; m++) {
int i = 1;
while (i < n) {
i = i * 2;
System.out.println("线性对数阶：" + i);
}
}
线性对数阶O(nlog平方n)其实非常容易理解，将对数阶O(log平方n)的代码循环n遍的话，那么它的时间复杂度就是 n * O(log平方n)，也就是了O(nlog平方n)，归并排序的复杂度就是O(nlog平方n)。
若n = 2 则程序执行2次，若n=4,则程序执行8次，依次类推
3.5.平方阶O(n²)
for(int i=0;i<n;i++){
for(int j=0;j<n;i++){
//复杂度为O(1)的算法
...
}
}上面的代码是循环嵌套，内层循环的时间复杂度在讲到线性阶时就已经得知是O(n)，现在经过外层循环n次，那么这段算法的时间复杂度则为O(n²)。接下来我们来算一下下面算法的时间复杂度：
n+(n-1)+(n-2)+(n-3)+……+1
=(n+1)+[(n-1)+2]+[(n-2)+3]+[(n-3)+4]+……
=(n+1)+(n+1)+(n+1)+(n+1)+……
=(n+1)n/2
=n(n+1)/2
=n²/2+n/2
根据此前讲过的推导大O阶的规则的第二条：只保留最高阶，因此保留n²/2。根据第三条去掉和这个项的常数，则去掉1/2,最终这段代码的时间复杂度为O(n²)。
同理，立方阶就为O(n3)，如果3改为k，那就是k次方阶O(nk)，相对而言就更复杂了。
从上图可以得出结论，当x轴n的值越来越大时，y轴耗时的时长为：
O(1) < O(logn) < O(n) < O(nlogn) < O(n2)
在编程算法中远远不止上面4种，比如O(n3)，O(2n)，O(n!)，O(nk)等等。
这些是怎么在数学的角度去证明的，感兴趣的可以去看看主定理。
注：以下数据来自于Big-O Cheat Sheet，常用的大O标记法列表以及它们与不同大小输入数据的性能比较。
| 大O标记法 | 计算10个元素 | 计算100个元素 | 计算1000个元素 |
|---|---|---|---|
| O(logN) | 3 | 6 | 9 |
| O(N) | 10 | 100 | 1000 |
| O(NlogN) | 30 | 600 | 9000 |
| O(N2) | 100 | 10000 | 1000000 |
| O(2N) | 1024 | 1.26e+29 | 1.07e+301 |
| O(N!) | 3628800 | 9.3e+157 | 4.02e+2567 |
3.空间复杂度
空间复杂度表示的是算法的存储空间和数据之间的关系，即一个算法在运行时，所消耗的空间。
空间复杂度的阶
空间复杂度相对于时间复杂度要简单很多，我们只需要掌握常见的O(1)，O(n)，O(n2)。
3.1.常数阶O(1)
int i;
3.2.线性阶O(n)
int[] arr;
3.3.平方阶O(n2)
int[][] arr;
1240
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
