走进数据结构和算法（c++版）（1）――算法时间复杂度

算法时间复杂度定义
T(n)$T(n)$是关于问题规模n$n$的函数，进而分析T(n)$T(n)$随n$n$的变化情况并确定T(n)$T(n)$的数量。算法的时间复杂度。也就是算法的时间量度，记做：T(n)=O(f(n))$T(n)=O(f(n))$。它表示随问题规模n$n$的增大，算法执行时间的增长率和f(n)$f(n)$的增长率相同，称作算法的渐近时间复杂度，简称为时间复杂度。 其中f(n)$f(n)$是问题规模n$n$的某个函数。

T(n)$T(n)$随问题规模n$n$增加的变化趋势。一般情况下，随着n$n$的增大，T(n)$T(n)$增长最慢的算法为最优算法。

1. 用常数 1 取代运行时间中的所有加法常数。
2. 再修改后的运行次数函数中，只保留最高阶项。
3. 如果最高阶项存在且不是 1 ，则去除与这个项相乘的常数。

时间复杂度O(1)$O(1)$

int a=1,b=3,sum=0;//执行1次 sum=a+b;//执行1次 cout<<"sum="<<sum<<endl;//执行1次

时间复杂度O(n)$O(n)$

for(int i = 0; i < n; i++)//执行n次 {     cout<<i<<endl; }   

时间复杂度O(n2)$O(n^2)$

for(int i = 0; i < n; i++)//执行n^2次 {     for(int j = 0; j < n; j++)     {         cout<<i<<endl;     } }   

O(n)$O(n)$，则n$n$层嵌套的时间复杂度为O(nn)$O(n^n)$。

时间复杂度O(logn)$O(logn)$

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

2x<n$2^x<n$时结束循环。所以总共执行了x=log2n$x=lo{g}_{2}n$次，所以其时间复杂度为O(logn)$O(logn)$。

O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n3)<O(2n)<O(n!)<O(nn)$$O(1)<O(logn)<O(n)<O(nlogn)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)$$

最坏情况

平均情况

递归算法的时间复杂度求解

T(n)=aT(n/b)+f(n)$$T(n)=aT(n/b)+f(n)$$

a≥1$a\ge 1$和b>1$b>1$是常数，f(n)$f(n)$是渐近正函数。

1. 若对某个常数ε>0$\epsilon >0$,有f(n)=O(n(logba)ε)$f(n)=O(n^{(lo{g}_{b}a)\epsilon })$,则T(n)=Θ(nlogba)$T(n)=\mathrm{\Theta }(n^{lo{g}_{b}a})$
2. 若f(n)=Θ(nlogba)$f(n)=\mathrm{\Theta }(n^{lo{g}_{b}a})$,则T(n)=Θ(nlogbalgn)$T(n)=\mathrm{\Theta }(n^{lo{g}_{b}a}lgn)$
3. 若对某个常数ε>0$\epsilon >0$,有f(n)=Ω(n(logba)+ε)$f(n)=\mathrm{\Omega }(n^{(lo{g}_{b}a)+\epsilon })$，且对于某个常数c<1$c<1$和所有足够大的n$n$有af(n/b)≤cf(n)$af(n/b)\le cf(n)$，则T(n)=Θ(f(n))$T(n)=\mathrm{\Theta }(f(n))$

T(n)=4T(n/2)+n$T(n)=4T(n/2)+n$，其中a=4,b=2$a=4,b=2$,logba=2$lo{g}_{b}a=2$。当ε=1$\epsilon =1$，有O(n(logba)ε)=O(n(log24)1)=O(n)$O(n^{(lo{g}_{b}a)\epsilon })=O(n^{(lo{g}_{2}4)1})=O(n)$。符合第一种情况所以T(n)=Θ(n2)$T(n)=\mathrm{\Theta }(n^2)$。

文章来源: 走进数据结构和算法（c++版）（1）――算法时间复杂度