时间复杂度

• 时间维度：是指执行当前算法所消耗的时间，通常[时间复杂度]来表示
• 空间维度：是指当前算法需要占用多少内存空间，通常用[空间复杂度] 来表示。

时间复杂度：

• 时间复杂度的计算通常用大O表示法即：T(n)=O(f(n));求时间复杂度就是对T（n）的数量级分析
• T（n）的数量级就是对算法中基本运算（基本运算——内层深层循环语句）的频度（一条语句在算法中被重复的次数叫做频度）f（n）的求解
• 取出f（n）中随n增长最快的项
• 将其系数置为1；即为T（n）的数量级。
• 简单来说就是找到执行次数最多那句，对它的执行次数进行求解。

int count =0;
for（int i= 0;i<n; i*=2）{
count ++;
}

比如说这组代码count++即最深层循环语句所以就是对count++的数量接分析。

通过下面几道题深度理解一下

public void fun(int n){
int i=1;
while(i<=n){
i=i*2;
    }
}

解：i=2*i --> i=1*2*2*2*2*2*2。。。。
   一直乘了t个2；
 即2^t<=n
 t<=log2(n)
 所以它的时间复杂度为T（n）=O（log2(n)）

int x=2;
while(x<n/2){
x=2*x;
};

解：x=2*x --> 2*2*2*2*2*2*2
 一直乘了t个2；
 2*2^t < n/2
 2^(t+2)<n
     t<log2(n)-2
去掉系数和常数
 时间复杂度为  T（n）=O(log2(n)) 

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

 

解：外层*内层
内层循环了n次  
外层 k=1*2*2*2 第一题已经算过是log2(n) 
时间复杂度为  T(n)=O(nlog2(n))

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

解：sum =1+2+3+4+5+。。。。+t<n
   (1+t)t/2<n;
  t^2+t-2n<0

不能为负
所以
t= 
系数和常数去掉
时间复杂度为 T(n)=O(n^(1/2)) 

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

解：
0*0*0<=n
1*1*1<=n
2*2*2<=n

t*t*t<=n
所以：t^3<=n
          t<=n^(1/3);
 时间复杂度为：T(n)=O(n^(1/3))

int m =0;
for (int i=n-1;i>1;i--){
    for(int j=1;j<1;j++){
     m++;
    }
}

解：这个相对复杂一点

 i           j           内部循环次数  
n-1        [1~n-2]       n-2次
n-2        [1~n-3]       n-3次
 .            .           .
 .            .           .
 .            .           .
 2          [1~1]         1次

所以内部循环次数为：(1+（n-2）)*(n-2)/2
    最后出（n^2-3n+2）/2
 时间复杂度为 T（n）=O(n^2)

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

解：和上题同理

i        j        内层循环次数
       
1       [1~2]        2
2       [1~4]        4
3       [1~6]        6
。        。         。
。        。         。
n       [1~n]        2n

等差数列求和： (2+2n)*n/2=n^2+n
  
时间复杂度为 T(n)=O(n^2)