分析复杂度三个方法：
1.只关注循环执行次数最多的一段代码
int cal(int n) {
int sum = 0;
int i = 1;
for (; i <= n; ++i) {
sum = sum + i;
}
return sum;
}
unit_time为一行代码执行时间
T(n) = (2 + 2n) * unit_time
f(n)为每行代码执行的次数总和
T(n) = O( f(n) ) = O(2 + 2n)
由于公式中的低阶、常量、系数三部分并不左右增长趋势，所以都可以忽略。
T(n) = O(n)
2.加法法则：总复杂度等于量级最大的那段代码的复杂度
int cal(int n) {
int sum_1 = 0;
int p = 1;
for (; p < 100; ++p) {
sum_1 = sum_1 + p;
}
int sum_2 = 0;
int q = 1;
for (; q < n; ++q) {
sum_2 = sum_2 + q;
}
int sum_3 = 0;
int i = 1;
int j = 1;
for (; i <= n; ++i) {
j = 1;
for (; j <= n; ++j) {
sum_3 = sum_3 + i * j;
}
}
return sum_1 + sum_2 + sum_3;
}
这段代码分为3部分，分别为求sum_1、sum_2、sum_3，其中sum_1执行次数为100次由于是常量即使是100000次都与n无关，当n无限大时就可以忽略。第二段和第三段代码时间复杂度分别为O(n)和O(n²)。综合这三部分的时间复杂度，选取最大量级因此这段代码的时间复杂度为为O(n²)。
总结：总的时间复杂度就等于量级最大的那段代码的时间复杂度。抽象为公式：
如果 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.乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积
int cal(int n) {
int ret = 0;
int i = 1;
for (; i < n; ++i) {
ret = ret + f(i);
}
}
int f(int n) {
int sum = 0;
int i = 1;
for (; i < n; ++i) {
sum = sum + i;
}
return sum;
}
类比加法公式可得乘法公式为：
如果 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))
单独看cal()，假设f()为普通操作，那么T1(n)=O(n)。但f()的时间复杂度为T2(n)=O(n),所以整个cal()的时间复杂度为
T(n)=T1(n)T2(n)=O(nn)=O(n²)
常见时间复杂度：
复杂度量级可分为多项式量级和非多项式量级。上表中仅指数阶和阶乘阶为非多项量级，随着n变大，非多项式量级算法执行时间会急剧增加，因此非多项式时间复杂度算法是非常低效的算法。
1. O(1)
只要代码的执行时间不随n的增大而增大，这样代码的时间复杂度都记为O(1)。一般情况下，只要算法中不存在循环语句、递归语句，无论有多少代码时间复杂度都为O(1)
2. O(logn)、O(nlogn)
int i = 1;
while (i <= n) {
i = i * 2;
}
每一次循环i的值乘以2，因此i的取值为等比数列，如下图：
求得x即为代码执行次数，求得
,时间复杂度为
另：无论以几为底,都可以把对数阶的时间复杂度写为记为。如
,可得:
由于前者为常量系数因此在计算时间复杂度时可以忽略。因此在时间复杂度中我们忽略对数底，统一表示为。利用上文讲述的乘法法则，当循环n次执行
的代码时，时间复杂度即为
。归并排序，快速排序时间复杂度都为
。
3. O(m+n)、O(m*n)
int cal(int m, int n) {
int sum_1 = 0;
int i = 1;
for (; i < m; ++i) {
sum_1 = sum_1 + i;
}
int sum_2 = 0;
int j = 1;
for (; j < n; ++j) {
sum_2 = sum_2 + j;
}
return sum_1 + sum_2;
}
由于我们无语预知m与n，因此无法判断m与n的量级谁更大，不能进行省略，因此上文中的加法原则在此处并不适用，上述代码的时间复杂度为。
在这种情况下，原先加法法则不正确，我们需要修改加法法则为：
乘法法则仍然有效为：
