时间复杂度，空间复杂度

算法的复杂度分析主要包含两个方面：

时间复杂度分析
空间复杂度分析

为什么要进行复杂度分析？

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)

总结

复杂度分析的三个原则

常见的几个复杂度的量级