数据结构—— 时间复杂度计算

时间复杂度抽象的表示了算法执行的基本操作次数，用来描述算法运行时间和输入数据量之间的关系。而大O符号，正式称呼为"大O表示法"，是表示时间复杂度的一种方法，他给出了算法运行时间随着输入规模增长的上界，是我们可以比较不同算法的效率。 

下面是一些例子更好了解大O法。

关于它的计算可以分为以下几种：

非递归	单层循环	O(1)
		O(u)
		O()
		O( U)
	多层循环	直观
		计算
递归	主定理	T(n)=aT()+f(n)
	树状图

单层循环

一般分为，表格中四种情况。下边结合代码，让你更清楚的理解。

int num=0
for(int i=0;i<100;i++)
num++;

 显然这个进行了100次++，这是一个常数值，常数值的复杂度就是O(1),

如果将100换成N,N是一个变量，在求复杂度时，默认N是一个无限大的数，所以复杂度是O(N).如果换成，当N无穷大时，不考虑系数，主要看次数，都是一次，属于同一阶层，（可以类比一下高数中的高阶低阶无穷小，次数相同时，属于同阶无穷小），所以还是O(N)

下边是关于表格中的后两种的例子,如果难看出来的话，可以列一下方程等式，如下：

int i=1;
while（i<=n)
i=i*2;

 循环次数    t=   i;

 终止时        i=    n;

 所以           t=   n;

 时间复杂度 

                      O（   n）；

一般默认log n（底数为2时），就是  n

y=0;
while((y+1)*(y+1)<=n)
y+=1;

 循环次数     t=  y;

 终止时        = n  ;

 所以            = n  ;

                    t=-1;

 时间复杂度 

                     O（ ）；

-1,在这里就可以直接忽略了

还有下面一种情况

for(int i=0;i<n;i++)
num++;
whilel(m--)
num*=2;

这个有两种写法

O(n)+O(m)

或者O(max(n,m)) 。

如果将m改成5，因为n无穷大，所以直接取O(n)就行了

 不同复杂度的大小：O(n！)>O()>O()>O(nlogn)>O(n)>O(log n)>O(1)

（在考研中，最坏和平均复杂度可以当成一回事 ，二者 等价。一个博主说的，我也不太懂）

在单层循环中，还有一种二分查找，有n个数据 ，所以=n;查找k次，复杂度是log n;   

                                                                                                                                                             

 多层函数

一种通过对单层函数进行相乘

void func(int N)
{
  int num=0;
  for(int i=0;i<N;i++)
  for(int j=0;j<N;j++)
   num++;     //显然这个双重函数，两个O(N)相乘，为O(n^2)


  int m=5;    //注意这个常数
  for(int i=0;i<N;i++)//O(N)
  while(M--)  //m是常数这个为O（1）    
   num++;     //这两个循环复杂度O(N)*O(1),还是O(N)
}

整个函数，复杂度为O()+O(N).。由于之前提到的只看最高次，所以复杂度写成O( ）

int count=0;
for(int i=1;i<=N;i+=2)   //外层为O (logN)
for(int j=1;j<=i;j++)    //内层为O (N )
count++;                 //整体就是O(Nlog N)

 这也是，可以直观看出来的复杂度，外内层相乘。

另一种需要计算，等差，等比数列的和.....

外层循环	i=1	i=2	i=4	i=6	......	i=N
内层循环次数	1	2	4	6	......	i=N

显然这是一个等差数列 ，所以sum=(1+N)/2*N=N/2+N^2/2;只看最高次，忽略系数

所以时间复杂度为O(）。

冒泡排序也是O（)

for(int i=1;i<=N;i*=2)
for(int j=1;j<=i;j++)
n++;

外层循环	i=1	i=2	i=4	i=8	......	i=N
内层循环次数	1	2	4	8	......	i=2N

显然这是一个等比数列 ，结合下图等比数列求和，

 所以sum=1*（1-2^logN)/(1-2)=2N-1;只看最高次，忽略系数

                     所以时间复杂度为O( N）

for(int i=0;i<N;i++)
for(int j=0;j<=i;j++)
for(int k=0;k<=j;k++)
n++;

对于一些三层循环，可以类比，两重循环，可以看作是平面面积，三层循环可以看作体积如下图

复杂度也就是O()

递归

主定理，T(n)=aT()+f(n)，一般解决b>1;

树状图，b=1,比如T(n)=T(n-1)+n，这种只能用树状图解决

关于递归的我也不太清楚，我说明一下，这里有部分内容是我学习借鉴的一个视频里的，

链接我放下边了，想了解的可以看一下，不过视频里我发现存在一点问题，关于等差数列的，这个需要注意。

【考研数据结构之时间复杂度（含递归）-哔哩哔哩】 https://b23.tv/KhGGgvx