算法的复杂度分析主要包含两个方面：
时间复杂度分析
空间复杂度分析
为什么要进行复杂度分析？
1：和性能测试相比，复杂度分析有不依赖执行环境、成本低、效率高、易操作、指导性强的特点。
2：掌握复杂度分析，将能编写出性能更优的代码，有利于降低系统开发和维护成本。
1：时间复杂度表示法
算法的执行效率，粗略地讲，就是算法代码执行的时间，那如何在不直接运行代码的前提下粗略的计算执行时间呢？
先来看一段简短的代码，求：1，2，3，4......n累加和
int sum(int n){
int sum =0; //执行一遍
for(i=0;i<n;i++){//执行n遍
sum=sum+i;//执行n遍
}
return sum;
}假设每行代码执行时间都一样为：timer，那此代码的执行时间为多少呢：(2n+1)*timer，由此可以看出来，所有代码的执行时间T(n)与代码的执行次数成正比。按照该思路我们接着看下面一段代码
int sum(int n)
{ int sum = 0;//执行一遍
for (int i=1; i <= n; ++i) { //执行n遍
for (int j=1; j <= n; ++j) { //执行n*n遍
sum = sum + i * j;//执行n*n遍
}
}
}同理，此代码的执行时间为：(2n*n+n+1) * timer
因此有一个重要结论：代码的执行时间T(n)与每行代码的执行次数n成正比 ，我们可以把这个规律总结成一个公式。
T(n) = O(f(n))
解释一下：T(n)表示代码的执行时间，n表示数据规模的大小，f(n)表示了代码执行次数的总和，它是一个公式因此用f(n)表示，O表示了代码执行时间与f(n)成正比
因此第一个例子中的T(n)=O(2n+1)，第二个例子中的T(n)=O(2n*n+n+1)，这就是大O时间复杂度表示法
大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度，简称时间复杂度。
时间复杂度分析方法：
1、代码循环次数最多原则
分析一个算法或者一个代码的时间复杂度时，只需关注循环执行次数最多的那一段代码即可
例如
int test(int n){
int sum=0
int i=0;
for(i=0;i<n;i++){
sum=sum+i;//循环内执行次数最多，n次，因此，这段程序的时间复杂度记为0(n)
}
return sum;
}2、加法原则
int sum(int n){
//常量级 忽略
int sum_1=0;
int p=0;
//执行了100次，属于常量 ，忽略
for(;p<100;p++){
sum_1+=p;
}
// 常量级：忽略
int sum_2 = 0;
int q = 1;
//循环n次，时间复杂度为：O(n)
for (; q < n; ++q) {
sum_2 = sum_2 + q;
}
// 常量级：忽略
int sum_3 = 0;
int i = 1; int j = 1;
//嵌套循环，时间复杂度为：O(n*n)
for (; i <= n; ++i) {
j = 1;
for (; j <= n; ++j) {
sum_3 = sum_3 + i * j;
}
}
return sum_1 + sum_2 + sum_3;
}
}其中两段最大量级的复杂度分别为O(n)和O(n*n)，其结果本应该是：T(n)=O(n)+O(n * n)，我们取其中最大的量级，因此整段代码的复杂度为：O(n * n)
也就是说：总的时间复杂度就等于量级最大的那段代码的时间复杂度
3、乘法原则
嵌套代码的复杂度等于嵌套内外代码复杂度的乘积，举个例子
int sum(int n) {
int ret = 0;
int i = 1;
//单独看是:O(n),由于func(i)是O(n)因此整体是:O(n) * O(n) = O(n*n) = O(n*n)
for (; i < n; ++i) {
ret = ret + func(i);//f(i)是O(n)
}
}
// O(n)
int func(int n) {
int sum = 0;
int i = 1;
for (; i < n; ++i) {
sum = sum + i;
}
return sum;
}因此可以看出：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积
常见的时间复杂度
O(1)，代码只有三行，它的复杂度也是O（1），而不是O（3）
public void test1(){
int i= 0;
int j= 1;
return i+j;
}因此总结下来就是：只要代码的执行时间不随着n的增大而增大，这样的代码复杂度都是O(1)，或者说：只要在算法中不存在递归语句，随n变化的循环语句等，即使有千万行代码，复杂度也是O(1)
O(n)
public void test03(int n){
int i =0;
int sum=0;
for(i=0;i<n;i++){
sum=sum+i;
}
System.out.println(sum);
}O(logn) ,O(nlogn)
public void test04(int n){
int i=1;
while(i<n){
i=i*2;
}
}我们知道对数有一个换底公式：，因此,而以3为底，2的对数是一个常量系数，基于我们前面的讨论，使用大O标记时间复杂度时不考虑低阶，系数，常量，所以在对数阶时间复杂度中我们忽略对数的底统一表示为：0(logn)
下面还有O(n*logn)
public void test06(int n){
int i=0;
for(;i<=n;i++){
test04(n);
}
}最好、最坏、平均时间复杂度
//其中n表示数组 array 的长度
public int getX(int[] array, int n, int x) {
int i = 0;
int pos = -1;
for (; i < n; ++i) {
if (array[i] == x) {
pos = i; break;
}
}
return pos;
}要查找的变量x在可能在数组中的任意位置，如果数组中的第一个元素就是我们要找的变量x，那就不需要继续变量余下的n-1个元素了，那复杂度为O(1),如果数组中不存在变量x那需要完整的遍历一遍数组，那复杂度就是O(n)。所以：在不同的情况下，同一段代码的复杂度并不一样
最好、最坏复杂度
最好情况复杂度：在最理想的情况下代码的时间复杂度
最坏情况复杂度：在最糟糕的情况下代码的时间复杂度
空间复杂度
时间复杂度的全称是渐进时间复杂度，表示算法的执行时间与数据规模之间的增长关系，类比一下，空间复杂度全称是渐进空间复杂度，表示算法占用的存储空间与数据规模之间的增长关系
void print(int n) {
int i = 0;
int[] a = new int[n];
for (i; i <n; ++i) {
a[i] = i * i;
}
for (i = n-1; i >= 0; --i) {
System.out.println(a[i]);
}
}代码第二行，申请一个空间存储变量i，但是是常量阶的，跟数据规模n没有关系，第三行申请了一个大小为n的int数组，此外后面的代码几乎没有占用更多的空间，因此整段代码的空间复杂度就是O(n)
总结
复杂度分析的三个原则
常见的几个复杂度的量级
