时间复杂度和空间复杂度
衡量算法的执行时间和空间
1. 引例
1.1 引例1
下面函数中，假设数组有n个元素，下面程序执行了多少次
function sum(A){
let sum = 0 // 执行1次
for (let i = 0; i < A.length; i++) { // i = 0执行了1次,i < A.length执行了n+1次，i++执行了n次
sum += A[i] // 执行了n次
}
return sum // 执行了1次
}
所以以上代码执行次数为3n+4次，即
T = 3n + 4
时间复杂度记作O(n)
1.2 引例2
下面函数中，n*n的二维数组求和，下面程序执行了多少次
function sum(A){
let sum = 0 // 执行1次
for (let i = 0; i < A.length; i++) { // i = 0执行了1次,i < A.length执行了n+1次，i++执行了n次
for (let j = 0; j < A[i].length; j++) { // j = 0执行了n次,j < A.length执行了n(n+1)次，j++执行了n*n次
sum += A[i][j] // 执行了n*n次
}
}
return sum // 执行了1次
}
所以以上代码执行次数为3n^2 + 4n + 4次，即
T = 3n^2 + 4n + 4
时间复杂度记作O(n^2)
1.3 引例总结
- 随着规模的增长O(n^2)的算法比O(n)的算法增长更快
- 在 T = an^2 + bn + c的算法中，n^2起决定作用
- 通常的，算法在更大输入集合的表现更有意义
- nnn的三维数组求和，程序执行的次数是 T = an^3 + bn^2 + cn + d,时间复杂度记作O(n^3)
- 以此类推，x维数组求和，时间复杂度O(n^x)
- 我们其实不用去算时间复杂度，只要找到关键之处，就能看出来，比如以下求出nm的二维数组求和，时间复杂度是O(nm)，因为值需要看最核心的sum+=A[i][j]就可以了。
function sum(A){
let sum = 0
for (let i = 0; i < A.length; i++) {
for (let j = 0; j < A[i].length; j++) {
sum += A[i][j] // 执行了n*m次
}
}
return sum
}
- 所有执行时间是一个常数的，即 T = C，那么时间复杂度为O(1)
2. 时间复杂度
时间复杂度用于衡量执行时间随着输入规模增加而增长的关系，是一种对算法的分类，并不是算法的具体执行时间
2.1 举例
2.1.1 举例1
求出n*m的二维数组求和，时间复杂度是多少
function sum(A){
let sum = 0
for (let i = 0; i < A.length; i++) {
for (let j = 0; j < A[i].length; j++) {
sum += A[i][j] // 执行了n*m次
}
}
return sum
}
只要找到最核心的代码，也就是次数最高的代码，根本不需要管前面的系数，所以这里的时间复杂度为O(m*n)
2.1.2 举例2
长度为n的数组A和长度为m的数组B合并,时间复杂度是多少?
function merge(A, B) {
let r = []
for (let i = 0; i < A.length; i ++) {
r.push(A[i]); // 执行了n次
}
for (let i = 0; i < A.length; i ++) {
r.push(B[i]); // 执行了m次
}
return r
}
时间复杂度为O(n + m)
2.1.3 举例3
对规模为n的数组第0项和第n项求和，时间复杂度是多少
function sum_head_tail(A) {
return A[0] + A[A.length - 1]
}
对于这类时间是一个常数的，即 T = C，我们记作时间复杂度为O(1)
2.1.4 举例4
对规模为n的数组，加和约一半元素，时间复杂度是多少？
function sum(A) {
let sum = 0
for (let i = 0; i < A.length/2; i++) {
sum += A[i] // 执行了n/2次
}
return sum
}
上面的sum += A[i]执行了n/2次，那么这个时间复杂度不是O(n/2)，只记作O(n)，不用管系数
3. 空间复杂度
空间复杂度是指算法用了多少额外的空间
每天下班学习到12点，一定会有所收获的，加油！未完待续！
