算法复杂度

一、算法复杂度

    算法本质是“快”和“省”。从时间上考虑是时间复杂度（快不快），从空间上考虑是空间复杂度（占用内存多不多）。
	算法复杂度记作O(n)，表示数据规模为n的情况下，算法使用的时间和空间资源，也就是代码执行花费的时间和空间随着n增大变化的趋势。

二、时间复杂度

计算时间复杂度方法：
没有循环，时间复杂度：O(1)
 有循环：从最内层循环开始,
  1、确定变量取值范围
  2、确定变量每次取值的时间复杂度，记为f(n)
  3、循环相加f(n)
 重复1到3步，即可计算出嵌套循环的时间复杂度
时间复杂度比较：
O(1) < O(logn) < O(n) < O(nlogn)<O(n^2)

1、O(1)

public void method1(int n){
    int a = 5; // 执行1次
    int b = 6; // 执行1次
    int c =  a + b;// 执行1次
    System.out.println(c);// 执行1次
}

没有循环，时间复杂度：O(1)

2、O(logn)

public void method10(int n){
    for (int i = 1 ; i <= n; i*=2) {
        System.out.println("heihei");
    }
}

i取值范围：2的0次方，2的1次方，2的2次方…2的log(n/2)次方。
执行次数为:1+log(n/2)
忽略系数，时间复杂度为：O(logn)

3、 O(n)

public void method2(int n){
for (int i = 1 ; i <= n; ++i) {
System.out.println(“haha”); // 第3行
}
}
i取值：1,2,3,4…,n
执行次数：n
时间复杂度为：O(n)

3、O(nlogn)

 public void method8(int n){

        for (int i = 1 ; i <= n; i*=2) {
            System.out.println("haha");

            for (int j = 1 ; j <= n; ++j) {
                System.out.println("heihei");
            }

        }

    }

第二个for执行次数为：n
第一个for实际取值范围：
i = 2的0次方 时，第二个for执行n次
i = 2的1次方 时，第二个for执行n次
i = 2的2次方 时，第二个for执行n次
…
i = 2的log2的n时，执行n次
执行次数：n + n + n + …+n （一共log2的n + 1 个 n）= n * (1 + log2的n)
忽略系数，时间复杂度：O(nlogn)

3、O(n^2)

public void method3(int n){
    for (int i = 1 ; i <= n; ++i) { // 第2行   第1层嵌套
        System.out.println("haha"); // 第3行
        for (int j = 1 ; j <= n; ++j) { // 第4行  第2层嵌套
            System.out.println("heihei");// 第5行
        }
    }
}

第二个for执行次数：n
第一个for实际取值：
i = 1, 第二个for 执行 n 次
i = 2, 第二个for 执行 n 次
…
i = n, 第二个for执行 n 次
总共执行次数：n+n+…+n （一共 n 个 n）= n * n
时间复杂度：O(n^2)

4、O(n^3)

public void method3(int n){
    for (int i = 1 ; i <= n; ++i) { 
        System.out.println("haha"); 
        for (int j = 1 ; j <= i; ++j) { 
            System.out.println("heihei");// 第5行
        }
          for (int k = 1 ; k<= j; ++j) { 
            System.out.println("heihei");// 第5行
        }
    }
}

第三个for执行次数为：j
第二个for实际取值范围为：
j=1,第三个for执行 1 次
j=2,第三个for执行 2 次
j=3,第三个for执行 3 次
…
j=i,第三个for执行 i次
第二个for内的总循环次数：
1+2+3+…+i = i(i+1)/2
第一个for实际取值范围：
i = 1 , 执行 1*（1+1）/ 2,
i = 2 , 执行 2*（2+1）/2,
i = 3 , 执行 3*（3+1）/2,
…
i = n , 执行 n*（n+1）/2.
总共的和 O(n3)

5、最好，最坏，平均，均摊时间复杂度

最好时间复杂度：在最理想的情况下，执行这段代码的时间复杂度。就是代码最少执行多少次。
最坏时间复杂度：在最糟糕的情况下，执行这段代码的时间复杂度。就是代码最多------------------------------------执行多少次。
平均复杂度：最好与最坏的情况下一定会存在这其他的情况，累加 这些情况下的时间复杂度 乘以 每种情况出现的频率 即可求出平均时间复杂度。
平均时间复杂度 = 从i=1 到 i = n 的 O(i)*P(i) 总和。
O(i):i情况下花费的时间
P(i):出现i这种情况的概率

三、空间复杂度

空间复杂度全称：渐进空间复杂度。
表示算法的存储空间与数据规模之间的增长关系。比如将一个数组拷贝到另一个数组中，就是相当于空间扩大了一倍，比如跳跃表，hashmap的扩容。
由于现在硬件相对比较便宜，所以在开发中常常会利用空间来换时间，比如缓存技术，还有数据结构中的跳跃表。
在实际开发中我们也更关注代码的时间复杂度，而用于执行效率的提升