序:
在面试的时候,经常会询问到算法的题目,尤其是后端的面试,去一些互联网的大厂。那么解析一个题目的算法又很多种,面试官如何判断你这个算法是不是最优的算法。没错,判断一个算法的优秀程度,就是使用时间复杂度。
A.时间复杂度怎么计算?
个人总结出三个计算时间复杂度的规律
1、找到执行次数最多的语句
2、语句执行语句的数量级
3、用O表示结果
计算时间复杂度的3个出发点,掌握这三个出发点,那么一向搞不懂的时间复杂度就可以迎刃而解啦。
B.常用的时间复杂度所耗费的时间从小到大依次是:
O(1 )< O(logn) < O(n) < O(n*logn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)
C.常见的时间复杂度例子
git地址:https://github.com/startYao/25-years-old-effort-basics-demo-01.git
1.对于一个循环,假设循环体的时间复杂度为 O(n),循环次数为 m,则这个
循环的时间复杂度为 O(n×m)。
/**
* O(1)
*/
private static void complexForO1() {
System.out.println("O(1)");
}
/**
* O(n)
*/
private static void complexForOn(int n) {
for (int i = 1; i < n; i++) {
System.out.println("O(n)");
}
}
此时时间复杂度为 O(n × 1),即 O(n)。
2.对于多个循环,假设循环体的时间复杂度为 O(n),各个循环的循环次数分别是a, b, c...,则这个循环的时间复杂度为 O(n×a×b×c...)。分析的时候应该由里向外分析这些循环。
/**
* O(n^2) demo1
*/
private static void complexForOnSquare1(int n) {
for (int i = 1; i < n; i++) {
for (int j = 1; j < n; j++) {
System.out.println("O(n^2)");
}
}
}
此时时间复杂度为 O(n × n × 1),即 O(n^2)。
3.对于顺序执行的语句或者算法,总的时间复杂度等于其中最大的时间复杂度。
/**
* O(n^2) demo2
*/
private static void complexForOnSquare2(int n) {
for (int i = 1; i < n; i++) {
for (int j = 1; j < n; j++) {
System.out.println("O(n^2)");
}
}
for (int i = 1; i < n; i++) {
System.out.println("O(n)");
}
}
此时时间复杂度为 max(O(n^2), O(n)),即 O(n^2)。
4.对于条件判断语句,总的时间复杂度等于其中 时间复杂度最大的路径 的时间复杂度。
/**
* O(n^2) demo3
*/
private static void complexForOnSquare3(int n) {
if (n >= 0) {
// 第一条路径时间复杂度为 O(n^2)
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.println("O(n^2)");
}
}
} else {
// 第二条路径时间复杂度为 O(n)
for (int j = 0; j < n; j++) {
System.out.println("O(n)");
}
}
}
此时时间复杂度为 max(O(n^2), O(n)),即 O(n^2)。
5.O(log(n))
/**
* O(log(n))
*
* 假设循环次数为 t,则循环条件满足 2^t < n。
* 可以得出,执行次数t = log(2)(n),即 T(n) = log(2)(n),可见时间复杂度为 O(log(2)(n)),即 O(log n)
*/
private static void complexForOnLog(int n) {
for (int i = 1; i < n; i++) {
i *= 2;
System.out.println("O(log(n))");
}
}
6.O(2^n)
/**
* O(2^n)
* 显然运行次数,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)
*/
private static int complexForO2SquareN(int n) {
if (n <= 1) {
return 1;
} else {
return complexForO2SquareN(n - 1) + complexForO2SquareN(n - 2);
}
}
剩余的,后续待补充...