0. 什么是时间频度？

一个算法的执行时间和算法中语句的执行次数成正比，也就是执行的语句越多，花费的时间越长。一个算法中语句的执行次数称为语句频度或时间频度。也就是说总的执行次数是循环次数 n 的一个函数，它通常用 T(n) 表示。
举例：

int count = 0;
for(int i = 0; i < n;  i++){
  count++;
}

上面算法时间频度 T(n) = n + 1（循环结束还需要进行一次判断）。

1. 什么是时间复杂度？

由上面的使劲频度可知，语句的重复执行次数是问题规模 n 的函数，用 T(n) 表示。当 n 趋于无限大时，可以找出一个辅助函数 f(n)，使得 T(n)/f(n) 趋于一个常数，则称 f(n) 是 T(n) 的同量级函数。这时可以用 O(f(n)) 来表示算法的渐进时间复杂度，简称时间复杂度。

T(n) 转换为 f(n) 和 时间复杂度：

1. 常数可以忽略，如：T(n) = n + 20，最终结果为 f(n) = n，时间复杂度为 O(n)
2. 低次项可以忽略，如：T(n) = n^2 + n，最终结果为 f(n) = n^2，时间复杂度为 O(n^2)
3. 系数可以忽略，如：T(n) = 5n^2 + 2n + 20，最终结果为 f(n)=n^2，时间复杂度为 O(n^2)

由上面的举例，可以看出，O(n) 相同的算法，T(n) 未必相同

2. 常见的时间复杂度

2.1 常数阶 O(1)

无论代码执行了多少行，只要没有循环等复杂结构时间复杂度为O(1)

int i = 1;
int j = 2;
i++;
j++;
int total = i+j;

上述代码时间消耗不会随着变量的增长而增长，即i=1或者i=10000都是一样的，无论有多少行，一行或者及万行都可以用O(1)来表示时间复杂度。

2.2 对数阶 O(log2n)

int i = 1;
int n = 1024;
while(i < n){
    i = i*2;
}
// 或者
for(int i=0; i<n; i*=2){
    System.out.println(i);
}

上述代码中while循环或者for 循环 的执行次数为 以2为底数1024的对数 log2N，当N增大时，时间频度成对数上升，类似于一根长16M的绳子，每次割一半，割到一米需要几次的问题，第一次为8M，第二次为4M，第三次为2M，第四次为1M，则时间频度具体值为4,为log16。则可以记做O(logn)。上述如果把i=i2改成 i=i3 则变成了 log3N 以3为底N的对数了.

2.3 线性阶 O(n)

int n =100;
for(int i=0; i<n; i++){
    System.out.println(i);
}

则表示for循环中需要执行多少次，上述代码是一个线性的，随着N的增加，执行次数就增加N次。如n=100 则执行100次 n=200则执行200次，在坐标轴上是一条直线上升的趋势。记为O(n)

2.4线性对数阶 O(nlog2n)

int n =100;
int m = 1024;
for(int i=0; i<n; i++){
       while(i < m){
        i = i*2;
    }
}

简单的理解就是一个对数阶的代码循环N遍则变成了线性对数阶，上述代码中 while循环是一个对数阶 为log1024 记做logN for循环是一个线性阶 n n=100 则他们一起的时间复杂度为O(nlogN)

2.5 平方阶 O(n^2)

int n = 100;
int m = 100;
for (i=0; i < n ; i++){
    for(i=0; i < m ;i++){
        System.out.println(i);
    }
}

平方阶就是循环套循环，2层循环就是一个n2的平方阶，时间复杂度就是O(n2)

2.6 立方阶 O(n^3)

立方阶则是3层循环嵌套

2.7 k 次方阶 O(n^k)

k层循环嵌套，这里的 k 是常数

2.8 指数阶 O(2^n)

long function1(int n) {    
    if (n <= 1) {        
        return 1;
    } else {        
        return function1(n - 1) + function1(n - 2);
    }
}

类似上述从出现递归的时候，T(0) = T(1) = 1，同时 T(n) = T(n - 1) + T(n - 2) + 1，这里的 1 是其中的加法算一次执行。显然 T(n) = T(n - 1) + T(n - 2) 是一个斐波那契数列，通过归纳证明法可以证明，当 n >= 1 时 T(n) < (5/3)^n，同时当 n > 4 时 T(n) >= (3/2)^n。所以该方法的时间复杂度可以表示为 O((5/3)^n)，简化后为 O(2^n)。

常见的算法时间复杂度由小到大依次为：Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜…＜Ο(2n)＜Ο(n!)

3. 时间复杂度分类

1. 最坏情况时间复杂度：代码在最理想情况下执行的时间复杂度。
2. 最好情况时间复杂度：代码在最坏情况下执行的时间复杂度。
3. 平均时间复杂度：用代码在所有情况下执行的次数的加权平均值表示
4. 均摊时间复杂度：在代码执行的所有复杂度情况中绝大部分是低级别的复杂度，个别情况是高级别复杂度且发生具有时序关系时，可以将个别高级别复杂度均摊到低级别复杂度上。基本上均摊结果就等于低级别复杂度。

一般用最怀时间复杂度来衡量算法

4. 算法稳定性

稳定排序算法会让原本有相等键值的纪录维持相对次序。也就是如果一个排序算法是稳定的，当有两个相等键值的纪录R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。

5. 常用的排序算法

5.1 冒泡排序
5.2 选择排序
5.3 插入排序
5.4 希尔排序
5.5 快速排序
5.6 归并排序
5.7 基数排序
5.8 计数排序

排序时间复杂度