大白话讲解举例时间复杂度的计算方式

一.关于时间复杂度

时间频度
一个算法执行所消耗的时间理论上是算不出来的，必须上机测试才知道。我们又不能将每一个算法都上机测试，但是我们知道每个算法所执行的时间一定和该算法的执行次数成正比。那个算法执行的次数越多，那么他花费的时间也就越多。
为此我们将算法中所有语句的频度之和即为T(n).
时间复杂度
前面提到的时间频度T(n)中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律，为此我们引入时间复杂度的概念。一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数，记作T(n)=O(f(n))，它称为算法的渐进时间复杂度，简称时间复杂度。
某算法的时间复杂度为O(n^2)表明该法的(执行时间与其成正比)

二、如何简单快速的判断算法的时间复杂度

• 快速的判断时间复杂度
  确定问题规模n
  循环减半过程logn
  k层关于n的循环—》n^k
• 复杂情况：根据算法执行过程判断
  从目前的情况来看图像法无法真正的实现计算时间复杂度，目前现在只能利用公式法
  公式法的基本执行情况如下图所示：从目前掌握的情况来看对于单层for循环需要判断

三、时间复杂度例题讲解

时间复杂度计算的计算方式
第一题：循环减半过程logn

for(int i=1;i<=n;i*=2){
	count ++;
}

找到基本运算：i = i*2; 
第一次执行：i = 1;
第二次执行：i = 2;
第三次执行：i = 4;
第四次执行：i = 8;
.......
第t次执行: i = 2^t; 
判断逻辑：i<= n; 
时间复杂度：2^t <= n  即：t <= log2n

第二题：

int n=8,count=0;
for(int i=1;i<=n;i*=2){
    for(int j=1;j<=i;j++){
        count++;    
    }
}

第一层for循环的执行次数：log2n
第二层第一次执行：1
第二层第二次执行：2
第二层第三次执行：4
第二层第四次执行：8
......
第二层第t次执行：2^t   t的最大值为log2n ----> 2^log2n
总的执行次数： 1 + 2 +4 + 8 +...+ 2^log2n = 2n -1 
时间复杂度：O(n)

第三题：

int m = 0,i,j;
for(i = 1;i<n;i++)
    for(j=1;j<=2*i;j++)
         m++;

第一层for循环的执行次数：n
第二层for循环的执行次数：log2n
时间复杂度：O(nlog2n)

第二题：

int func(int n){
	int i =0 ,sum = 0;
	while(sum < n){
	  sum += ++i;
	}
	return i;
}

找到基本运算：sum += ++i;
第一次执行：sum = 1
第二次执行：sum = 1+2
第三次执行：sum = 1+2+3 
第四次执行：sum = 1+2+3+4
第五次执行：sum = 1+2+3+4+5
......
第t次执行：sum = 1+2+3+4+...+t
判断逻辑：sum < n
时间复杂度：1+2+3+4+...+t < n  即： t + t(t-1)/2  < n ----> O(t^1/2)

第三题：

void fun(int n){
    int i = 0;
    while(i*i*i <= n){
        i++;    
    }
}

找到基本运算：(i++)^3  i = 0
第一次执行：0 * 0 * 0
第二次执行：1 * 1 * 1
第三次执行：2 * 2 * 2 
第四次执行：3 * 3 * 3
第五次执行：4 * 4 * 4
......
第t次执行：（t-1）^3 
判断逻辑：（t-1）^3 <= n
时间复杂度：O(n^1/3)

第四题：

x = 0;
while(n>=(x+1)*(x+1)){
    x = x + 1;
}

找到基本运算：(x+1)*(x+1)
第一次执行：x = 1 * 1 
第二次执行：x = 2 * 2 
第三次执行：x = 3 * 3 
第四次执行：x = 4 * 4 
......
第t次执行：x = t * t
判断逻辑：t^2 <= n
时间复杂度：O(n^1/2)

第五题：

for(i=0;i<n;i++)
    for(j =0;j<m;j++)
         a[i][j] = 0;

第一层for循环的执行次数：n
第二层for循环的执行次数：m
时间复杂度：O(n*m)