大O复杂度表示法
大O复杂度表示法，表示代码执行时间随数据规模增长的变化趋势，也叫作渐进时间复杂度，简称时间复杂度。
时间复杂度分析
1. 只关注循环执行次数最多的一段代码
T(n)=O(2+n+1)=O(n)
2. 加法法则：总复杂度等于量级最大的那段代码的复杂度
如果T1(n)=O(f(n))，T2(n)=O(g(n))；那么T(n)=T1(n)+T2(n)=max(O(f(n)), O(g(n)))=O(max(f(n), g(n)))
3. 乘法法则：嵌套代码的复杂度等于嵌套内外代码的复杂度的乘积
如果T1(n)=O(f(n))，T2(n)=O(g(n))；那么T(n)=T1(n)*T2(n)=O(f(n))*O(g(n))=O(f(n)*g(n))
常见时间复杂度实例分析
1. O(1)
一般情况下，只要算法中不存在循环语句、递归语句，即使有成千上万行的代码，其时间复杂度也是Ο(1)。
2. O(logn)、O(nlogn)
非常常见的算法时间复杂度，比如归并排序、快速排序的时间复杂度是O(nlogn)
3.O(m+n)、O(m*n)
代码复杂度由两个数据的规模决定。
空间复杂度分析
全称是渐进空间复杂度，表示算法的存储空间与数据规模之间的增长关系。
常见的空间复杂度有O(1)、O(n)、O(n2)
最好、最坏情况时间复杂度
// n表示数组array的长度
int find(int[] array, int n, int x) {
int i = 0;
int pos = -1;
for (; i < n; ++i) {
if (array[i] == x) pos = i;
}
return pos;
}以上代码是无序数组里查找变量x的位置 ，时间复杂度是O(n)
代码进行优化后：
// n表示数组array的长度
int find(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，这时候的时间复杂度是O(1)，如果数组里不存在变量x，那么时间复杂度是O(n)。
最好情况时间复杂度：在最理想的情况下，执行这段代码的时间复杂度。
最坏情况时间复杂度：在最糟糕的情况下，执行这段代码的时间复杂度。
平均情况时间复杂度
按上面的例子，把所有情况（有n+1种）：在数组的0~n-1位置中和不在数组中，把每种情况查找要遍历的元素个数累加起来，再除以n+1，就是平均遍历的元素个数的平均值：
时间复杂度的大O标记法中，可以省略掉系数、低阶、常量，所以，公式简化之后，得到的平均时间复杂度就是O(n)。
实际上还要考虑每种情况的出现的概率，比如每种情况出现的概率都是1/2，那么平均时间复杂度的推导公式：
引入概率之后，前面那段代码的加权平均值为(3n+1)/4。用大O表示法来表示，去掉系数和常量，这段代码的加权平均时间复杂度仍然是O(n)。
均摊时间复杂度
// array表示一个长度为n的数组
// 代码中的array.length就等于n
int[] array = new int[n];
int count = 0;
void insert(int val) {
if (count == array.length) {
int sum = 0;
for (int i = 0; i < array.length; ++i) {
sum = sum + array[i];
}
array[0] = sum;
count = 1;
}
array[count] = val;
++count;
}这段代码实现了一个往数组中插入数据的功能。当数组满了，就把数组里的求和，并清空数组，然后将求和放在数组的第一位。
最好情况时间复杂度：O(1)
最坏情况时间复杂度：O(n)
平均情况时间复杂度：O(1)。假设数组元素个数从0~n的概率一样，即1/(n+1)，那平均情况时间复杂度公式如下：
均摊时间复杂度：
看上面的例子（插入数据），每一次O(n)的插入操作，都会跟着n-1次O(1)的插入操作，把耗时多的那次操作均摊到接下来的n-1次耗时少的操作上，均摊下来的均摊时间复杂度是O(1)。
均摊时间复杂度是一种特殊的平均时间复杂度。
课后思考：
1、有人说，我们项目之前都会进行性能测试，再做代码的时间复杂度、空间复杂度分析，是不是多此一举呢？而且，每段代码都分析一下时间复杂度、空间复杂度，是不是很浪费时间呢？你怎么看待这个问题呢？
相对于做性能测试，时间复杂度、空间复杂度分析更加便捷、不需要额外的资源。在代码层面就已经做出判断，时间复杂度和空间复杂度不达标，重写代码即可。
而且性能测试是受测试环境影响，配置不一样，得出的结果不一样。
2、用今天学习的知识，来分析一下，下面这个add()函数的时间复杂度。
// 全局变量，大小为10的数组array，长度len，下标i。
int array[] = new int[10];
int len = 10;
int i = 0;
// 往数组中添加一个元素
void add(int element) {
if (i >= len) { // 数组空间不够了
// 重新申请一个2倍大小的数组空间
int new_array[] = new int[len*2];
// 把原来array数组中的数据依次copy到new_array
for (int j = 0; j < len; ++j) {
new_array[j] = array[j];
}
// new_array复制给array，array现在大小就是2倍len了
array = new_array;
len = 2 * len;
}
// 将element放到下标为i的位置，下标i加一
array[i] = element;
++i;
}最好时间复杂度：O(1)
数组空间不满，直接插入。
最坏时间复杂度：O(n)
数组空间满了，复制数组。
平均时间复杂度：O(1)
假设数组元素个数（0~n）的概率相同（1/n+1），那么计算公式为：
1/(n+1)+1/(n+1)+.......+n/(n+1)=2n/(n+1)=O(1)
均摊时间复杂度：O(1)
每次的复制数组操作（O(n)）都有n次的直接插入的操作（O(1)），均摊后是O(1)
