常见的时间复杂度算法

算法时间复杂度排行

O(1)常数阶 < O(logn)对数阶 < O(n)线性阶 < O(n^2)平方阶 < O(n^3)(立方阶) < O(2^n) (指数阶)

 

常见的时间复杂度举例

1简单的循环，时间复杂度为O(n）

for (long long i = 0; i < n; i++) {
        k++;
    }

  求x的n次方 for循环

int function1(int x, int n) {
    int result = 1;  // 注意 任何数的0次方等于1
    for (int i = 0; i < n; i++) {
        result = result * x;
    }
    return result;
}

求x的n次方 递归

int function2(int x, int n) {
    if (n == 0) {
        return 1; // return 1 同样是因为0次方是等于1的
    }
    return function2(x, n - 1) * x;
}

 

2.简单循环，时间复杂度为O(logn)

for (int i = 1; i <= n; i = i * 2) { 语句1； } 

这里我们可以把求时间复杂度看成求这个循环内语句一执行了多少次的问题。（但时间复杂度是一个级数趋近的变化概念）
假设该程序一共循环了k次，即第k次循环就会退出（注意增加条件为i = i * 2）
第1次 ，i = 1
第2次 ，i = 1*2 = 2^1
第3次 ，i = 122 = 2^2
第4次 ，i = 122*2 = 2^3
第k次 (最后一次)，i = 122*2…*2 = 2^(k-1)
第k次的时候，必然满足i <= n的条件，也即必然满足等式 2^(k-1) = n ，便反求得k = logn + 1 ,故O（n）= logn；
类似的乘法增长循环求时间复杂度都可以设循环次数k然后倒推出k，进而级数趋近变换得到时间复杂度

3.双层for循环 时间复杂度是 O(n^2)

for (long long i = 0; i < n; i++) {
        for (long j = 0; j < n; j++) {
            k++;
        }
    }

   冒泡排序

//最外层可以是n-1层 
for(i = 0 ; i < n-1; i++){
    //内层需要记住 存在j+1那么j最多只能取到倒数第二位；且趟循环总是那次循环的最后一个数换到最值，选择排序则是那一趟的第一个数与最值下标k交换；
	for(j = 0; j < n-(i+1)  ; j++ ){
		if(arr[j] > arr[j+1])
			swap(j,j+1);
	}
}

外循环一共会执行n-1次，而内循环条件为 j < n - (i + 1) ,按照循环规律依次写处内循环的循环次数：
当i=1时，内循环需要执行n-1次；
当i=2时，内循环需要执行n-2次；
当i=3时，内循环需要执行n-3次；
当i=n-2时，内循环需要执行n - (n - 2 + 1 ) = 1次；此时循环结束；
所以循环总执行次数：1 + 2 + 3 + … + n-1 = n（n-1） / 2 ;
故时间复杂度为O（N^2）;
最坏最好情况下时间复杂度都是 （N^2）；如何理解？
最好的情况就是上面推导的过程，也就是没有进swap进行交换，所以每一次内循环的代价都是0；所以为n（n-1） / 2；
最差情况下，也就是刚好倒序或者顺序，那么跟最好情况的区别就是每一次内循环都执行了swap函数，代价增加了三条交换语句，所以总时间复杂度增大为 3 *n（n-1） / 2 ，但其级数趋近后的式子仍然是O（n^2）!
 

4 斐波那契的递归算法 时间复杂度O（2^n）

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

有点像细胞分裂，每一次进入Fibonacci函数，就会分裂成两个小Fibonacci函数，这个两个小Fibonacci函数又会分裂出4个小小Fibonacci函数，至少要进入n次，故其时间复杂度为O（2^n）。