如何计算算法复杂度

1. 算法的时间复杂度如何计算

关于时间复杂度的计算是按照运算次数来进行的，比如1题：
Sum1(
int
n
)
{
int
p=1,
sum=0,
m
;
//1次
for
(m=1;
m<=n;
m++)
//n+1次键渗
{
p*=m
;
//n次
sum+=p
;
}
//n次
return
(sum)
;
//1次
}
最后总的次数为
1+（n+1）+n+n+1+1=3n+3
所以时间复杂度f（o）=n；（时间复杂度只管n的最高次方，不稿并脊管他的系数和表达式中的常量）
其余的一样，不明蔽态白的可以来问我

2. 算法空间复杂度具体怎么算

数据结构中算法空间复杂度计算方法：

一个算法的空间复杂度只考虑在运行过程中为局部变量分配的存储空间的大小，它包括为参数表中形参变量分配的存储空间和为在函数体中定义的局部变量分配的存储空间两个部分。

若一个算法为递归算法，其空间复杂度为递归所使用的堆栈空间的大小，它等于一次调用所分配的临时存储空间的大小乘以被调用的次数(即为递归调用的次数加1，这个1表示开始进行的一次非递归调用)。

空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度，记做S(n)=O(f(n))。

而一般的递归算法就要有O(n)的空间复杂度了，因为每次递归都要存储返回信息。一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。

3. 如何估算算法的复杂度

就是根据程序运行的最基本的操作的次数，记为t（n）
例：算法：
for（i=1;i<=n;++i）
{
for(j=1;j<=n;++j)
{
c[
i
][
j
]=0;
//该步骤属于基本操作
执行次数：n的平方
次
for(k=1;k<=n;++k)
c[
i
][
j
]+=a[
i
][
k
]*b[
k
][
j
];
//该步骤属于基本操作
执行次数：n的三次方
次
}
}
则有
t（n）=
n的平方+n的三次方，根据上面括号里的同数量级，我们可以确定
n的三次方
为t（n）的同数量级
则有f（n）=
n的三次方，然后根据t（n）/f（n）求极限可得到常数c
则该算法的
时间复杂度：t（n）=o（n^3）
注：n^3即是n的3次方。

4. 给出一个常见的计算算法,说说它的计算复杂度是如何计算的

一般用循环次数和嵌套备亩程李配度来判断哪滚指。例如一个双层循环，内层和外层都循环n次，那么总共循环就是n^2次，复杂度就是O（n^2）。

5. 如何计算算法复杂度

问题一：程序中的时间复杂度是怎么计算的？ 算法复杂度的介绍，见网络：
ke./view/7527
时间复杂度
时间频度
一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
计算方法
1. 一般情况下，算法的基本操作重复执行的次数是模块n的某一个函数f（n），因此，算法的时间复杂度记做：T（n）=O（f（n））
分析：随着模块n的增大，算法执行的时间的增长率和f（n）的增长率成正比，所以f（n）越小，算法的时间复杂度越低，算法的效率越高。
2. 在计算时间复杂度的时候，先找出算法的基本操作，然后根据相应的各语句确定它的执行次数，再找出T（n）的同数量级（它的同数量级有庆烂以下：1，Log2n ，n ，nLog2n ，n的平方，n的三次方，2的n次方，n！），找出后，f（n）=该数量级，若T(n)/f(n)求极限可得到一常数c，则时间复杂度T（n）=O（f（n））
例：算法：
for（i=1;i>

问题二：如何计算算法的时间复杂度 求解算法的时间复杂度的具体步骤是：⑴找出算法中的基本语句；算法中执行次数最多的那条语句就是基本语句，通常是最内层循环的循环体。⑵计算基本语句的执行次数的数量级；只需计算基本语句执行次数的数量级，这就意味着只要保证基本语句执行次数的函数中的最高次幂正确即可，可以忽略所有低次幂和最高次幂的系数。这样能够简化算法分析，并且使注意力集中在最重要的一点上：增长率。⑶用大Ο记号表示算法的时间性能。将基本语句执行次数的数量级放入大Ο记号中。如果算法中包含嵌套的循环，则基本语句通常是最内层的循环体，如果算法中包含并列的循环，则将并列循环的时间复杂度相指弯加。例如：for(i=1;i 问题三：C语言算法的时间复杂度如何计算啊？ 看看这个 每个循环都和上一层循环的参数有关。 所以要用地推公式： 设i(n)表示第一层循环的i为n时的循环次数，注意到他的下一层循环次数刚好就是n，分别是0,1,2...n-1 所以，把每一层循环设一个函数分别为：j(n),k(n),t(n) 则有 i(n)=j(0)+...+j(n-1) j(n)=k(0)+...+k(n-1) k(n)=t(0)+...+t(n-1) i(0)=j(0)=k(0)=0 t(n)=1 而总循环数是i(0)+i(1)...+i(n-1) 可以根据递推条件得出准确值 所以算法复杂度是O(i(0)+i(1)...+i(n-1))
记得采纳啊

问题四：如何计算算法的时间复杂度和空间复杂度 是说明一个程序根据其数据n的规模大小 所使用的大致时间和空间
说白了 就是表示 如果随着n的增长 时间或空间会以什么样的方式进行增长
例
for(int i = 0; i 问题五：一个算法的时间复杂度是什么函数？ 关于n的函数，n是问题的规模

问题六：请问递归算法的时间复杂度如何计算呢? 递归算法的时间复杂度分析 收藏
在算法分析中，当一个算法中包含递归调用时，其时间复杂度的分析会转化为一个递归方程求解。实际上，这个问题是数学上求解渐近阶的问题，而递归方程的形式多种多样，其求解方法也是不一而足，比较常用的有以下四种方法：
(1)代入法(Substitution Method)

代入法的基本步骤是先推测递归方程的显式解，然后用数学归纳法来验证该解是否合理。

(2)迭代法(Iteration Method)

迭代法的基本步骤是迭代地展开递归方程的右端，使之成为一个非递归的和式，然后通过对和式的估计来达到对方程左端即方程的解的估计。

(3)套用公式法(Master Method)

这个方法针对形如“T(n) = aT(n/b) + f(n)”的递归方程。这种递归方程是分治法的誉逗漏时间复杂性所满足的递归关系，即一个规模为n的问题被分成规模均为n/b的a个子问题，递归地求解这a个子问题，然后通过对这a个子间题的解的综合，得到原问题的解。

(4)差分方程法(Difference Formula Method)
可以将某些递归方程看成差分方程，通过解差分方程的方法来解递归方程，然后对解作出渐近阶估计。

下面就以上方法给出一些例子说明。

一、代入法

大整数乘法计算时间的递归方程为：T(n) = 4T(n/2) + O(n)，其中T(1) = O(1)，我们猜测一个解T(n) = O(n2 )，根据符号O的定义，对n>n0，有T(n) >

问题七：如何计算时间复杂度 如何计算时间复杂度
定义：如果一个问题的规模是n，解这一问题的某一算法所需要的时间为T(n)，它是n的某一函数 T(n)称为这一算法的“时间复杂性”。
当输入量n逐渐加大时，时间复杂性的极限情形称为算法的“渐近时间复杂性”。
我们常用大O表示法表示时间复杂性，注意它是某一个算法的时间复杂性。大O表示只是说有上界，由定义如果f(n)=O(n)，那显然成立f(n)=O(n^2)，它给你一个上界，但并不是上确界，但人们在表示的时候一般都习惯表示前者。
此外，一个问题本身也有它的复杂性，如果某个算法的复杂性到达了这个问题复杂性的下界，那就称这样的算法是最佳算法。
“大 O记法”：在这种描述中使用的基本参数是 n，即问题实例的规模，把复杂性或运行时间表达为n的函数。这里的“O”表示量级 (order)，比如说“二分检索是 O(logn)的”,也就是说它需要“通过logn量级的步骤去检索一个规模为n的数组”记法 O ( f(n) )表示当 n增大时，运行时间至多将以正比于 f(n)的速度增长。
这种渐进估计对算法的理论分析和大致比较是非常有价值的，但在实践中细节也可能造成差异。例如，一个低附加代价的O(n2)算法在n较小的情况下可能比一个高附加代价的 O(nlogn)算法运行得更快。当然，随着n足够大以后，具有较慢上升函数的算法必然工作得更快。
O(1)
Temp=i;i=j;j=temp;
以 上三条单个语句的频度均为1，该程序段的执行时间是一个与问题规模n无关的常数。算法的时间复杂度为常数阶，记作T(n)=O(1)。如果算法的执行时 间不随着问题规模n的增加而增长，即使算法中有上千条语句，其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)。
O(n^2)
2.1. 交换i和j的内容
sum=0； （一次）
for(i=1;i>

问题八：算法的时间复杂度 以下是考研时常用的计算方法，实际上最简单的方法采用多项式最大阶的方法，如：
f(n)=a1*n^m+a2*n^(m-1)+.......an-1*n+an
的时间复杂度为:T(f(n))=O(n^m)
采用时间步法，找一个函数g(n),找一个自然数n0,使f(n)T(n)=O(n)
(2)6n^2-12n+1=12)=7n^2=7*g(n)==>T(n)=O(n^2)
(3)n(n+1)(n+2)/6=n0=2时)=n0=4)=2*g(n)===>T(n)=O(n^3)
(4)2^(n+1)+100nT(n)=O(2^n)

6. 算法空间复杂度怎么算

算法空间复杂度计算方法：

一个算法的空间复杂度只考虑在运行过程中为局部变量分配的存储空间的大小，它包括为参数表中形参变量分配的存储空间和为在函数体中定义的局部变量分配的存储空间两个部分。

若一个算法为递归算法，其空间复杂度为递归所使用的堆栈空间的大小，它等于一次调用所分配的临时存储空间的大小乘以被调用的次数(即为递归调用的次数加1，这个1表示开始进行的一次非递归调用)。

算法的空间复杂度一般也以数量级的形式给出。如当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)；当一个算法的空间复杂度与以2为底的n的对数成正比时，可表示为O(log2n)；当一个算法的空间复杂度与n成线性比例关系时，可表示为O(n)。若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，以便由系统自动引用实参变量。

(6)如何计算算法复杂度扩展阅读：

空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度，记做S(n)=O(f(n))。比如直接插入排序的时间复杂度是O(n^2),空间复杂度是O(1) 。而一般的递归算法就要有O(n)的空间复杂度了，因为每次递归都要存储返回信息。一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。

个算法的空间复杂度S(n)定义为该算法所耗费的存储空间，它也是问题规模n的函数。渐近空间复杂度也常常简称为空间复杂度。空间复杂度(SpaceComplexity)是对一个算法在运行过程中临时占用存储空间大小的量度。一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。

7. 算法时间复杂度怎么算

一、概念
时间复杂度是总运算次数表达式中受n的变化影响最大的那一项(不含系数)
比如：一般总运算次数表达式类似于这样：
a*2^n+b*n^3+c*n^2+d*n*lg(n)+e*n+f
a ！ =0时，时间复杂度就是O(2^n);
a=0,b<>0 =>O(n^3);
a,b=0,c<>0 =>O(n^2)依此类推
eg:
(1) for(i=1;i<=n;i++) //循环了n*n次，当然是O(n^2)
for(j=1;j<=n;j++)
s++;
(2) for(i=1;i<=n;i++)//循环了(n+n-1+n-2+...+1)≈(n^2)/2，因为时间复杂度是不考虑系数的，所以也是O(n^2)
for(j=i;j<=n;j++)
s++;
(3) for(i=1;i<=n;i++)//循环了(1+2+3+...+n)≈(n^2)/2,当然也是O(n^2)
for(j=1;j<=i;j++)
s++;
(4) i=1;k=0;
while(i<=n-1){
k+=10*i; i++; }//循环了n-1≈n次，所以是O(n)(5) for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
for(k=1;k<=j;k++)
x=x+1;
//循环了(1^2+2^2+3^2+...+n^2)=n(n+1)(2n+1)/6(这个公式要记住哦)≈(n^3)/3，不考虑系数，自然是O(n^3)
另外，在时间复杂度中，log(2,n)(以2为底)与lg(n)(以10为底)是等价的，因为对数换底公式：
log(a,b)=log(c,b)/log(c,a)
所以，log(2,n)=log(2,10)*lg(n),忽略掉系数，二者当然是等价的
二、计算方法1.一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。
一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
2.一般情况下，算法的基本操作重复执行的次数是模块n的某一个函数f（n），因此，算法的时间复杂度记做：T（n）=O（f（n））。随着模块n的增大，算法执行的时间的增长率和f（n）的增长率成正比，所以f（n）越小，算法的时间复杂度越低，算法的效率越高。
在计算时间复杂度的时候，先找出算法的基本操作，然后根据相应的各语句确定它的执行次数，再找出T（n）的同数量级（它的同数量级有以下：1，Log2n ，n ，nLog2n ，n的平方，n的三次方，2的n次方，n！），找出后，f（n）=该数量级，若T(n)/f(n)求极限可得到一常数c，则时间复杂度T（n）=O（f（n））。
3.常见的时间复杂度
按数量级递增排列，常见的时间复杂度有：
常数阶O(1), 对数阶O(log2n), 线性阶O(n), 线性对数阶O(nlog2n), 平方阶O(n^2)， 立方阶O(n^3),...， k次方阶O(n^k), 指数阶O(2^n) 。
其中，1.O(n)，O(n^2)， 立方阶O(n^3),...， k次方阶O(n^k) 为多项式阶时间复杂度，分别称为一阶时间复杂度，二阶时间复杂度。。。。2.O(2^n)，指数阶时间复杂度，该种不实用3.对数阶O(log2n), 线性对数阶O(nlog2n)，除了常数阶以外，该种效率最高
例：算法：
for（i=1;i<=n;++i）
{
for(j=1;j<=n;++j)
{
c[ i ][ j ]=0; //该步骤属于基本操作 执行次数：n^2
for(k=1;k<=n;++k)
c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; //该步骤属于基本操作 执行次数：n^3
}
}
则有 T（n）= n^2+n^3，根据上面括号里的同数量级，我们可以确定 n^3为T（n）的同数量级
则有f（n）= n^3，然后根据T（n）/f（n）求极限可得到常数c
则该算法的 时间复杂度：T（n）=O（n^3)
四、

定义：如果一个问题的规模是n，解这一问题的某一算法所需要的时间为T(n)，它是n的某一函数
T(n)称为这一算法的“时间复杂性”。

当输入量n逐渐加大时，时间复杂性的极限情形称为算法的“渐近时间复杂性”。

我们常用大O表示法表示时间复杂性，注意它是某一个算法的时间复杂性。大O表示只是说有上界，由定义如果f(n)=O(n)，那显然成立f(n)=O(n^2)，它给你一个上界，但并不是上确界，但人们在表示的时候一般都习惯表示前者。

此外，一个问题本身也有它的复杂性，如果某个算法的复杂性到达了这个问题复杂性的下界，那就称这样的算法是最佳算法。

“大O记法”：在这种描述中使用的基本参数是
n，即问题实例的规模，把复杂性或运行时间表达为n的函数。这里的“O”表示量级 (order)，比如说“二分检索是 O(logn)的”,也就是说它需要“通过logn量级的步骤去检索一个规模为n的数组”记法 O ( f(n) )表示当 n增大时，运行时间至多将以正比于 f(n)的速度增长。

这种渐进估计对算法的理论分析和大致比较是非常有价值的，但在实践中细节也可能造成差异。例如，一个低附加代价的O(n2)算法在n较小的情况下可能比一个高附加代价的 O(nlogn)算法运行得更快。当然，随着n足够大以后，具有较慢上升函数的算法必然工作得更快。

O(1)

Temp=i;i=j;j=temp;

以上三条单个语句的频度均为1，该程序段的执行时间是一个与问题规模n无关的常数。算法的时间复杂度为常数阶，记作T(n)=O(1)。如果算法的执行时间不随着问题规模n的增加而增长，即使算法中有上千条语句，其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)。

O(n^2)

2.1.
交换i和j的内容
sum=0；（一次）
for(i=1;i<=n;i++)（n次 ）
for(j=1;j<=n;j++)
（n^2次 ）
sum++；（n^2次 ）
解：T(n)=2n^2+n+1 =O(n^2)

2.2.
for (i=1;i<n;i++)
{
y=y+1;①
for
(j=0;j<=(2*n);j++)
x++;②
}
解：
语句1的频度是n-1
语句2的频度是(n-1)*(2n+1)=2n^2-n-1
f(n)=2n^2-n-1+(n-1)=2n^2-2
该程序的时间复杂度T(n)=O(n^2).

O(n)

2.3.
a=0;
b=1;①
for
(i=1;i<=n;i++) ②
{
s=a+b;③
b=a;④
a=s;⑤
}
解：语句1的频度：2,
语句2的频度：
n,
语句3的频度： n-1,
语句4的频度：n-1,
语句5的频度：n-1,
T(n)=2+n+3(n-1)=4n-1=O(n).

O(log2n
)

2.4.
i=1;①
while (i<=n)
i=i*2; ②
解： 语句1的频度是1,
设语句2的频度是f(n),则：2^f(n)<=n;f(n)<=log2n
取最大值f(n)=
log2n,
T(n)=O(log2n )

O(n^3)

2.5.
for(i=0;i<n;i++)
{
for(j=0;j<i;j++)
{
for(k=0;k<j;k++)
x=x+2;
}
}
解：当i=m,
j=k的时候,内层循环的次数为k当i=m时, j 可以取 0,1,...,m-1 , 所以这里最内循环共进行了0+1+...+m-1=(m-1)m/2次所以,i从0取到n, 则循环共进行了: 0+(1-1)*1/2+...+(n-1)n/2=n(n+1)(n-1)/6所以时间复杂度为O(n^3).


我们还应该区分算法的最坏情况的行为和期望行为。如快速排序的最
坏情况运行时间是 O(n^2)，但期望时间是 O(nlogn)。通过每次都仔细 地选择基准值，我们有可能把平方情况 (即O(n^2)情况)的概率减小到几乎等于 0。在实际中，精心实现的快速排序一般都能以 (O(nlogn)时间运行。
下面是一些常用的记法：


访问数组中的元素是常数时间操作，或说O(1)操作。一个算法如 果能在每个步骤去掉一半数据元素，如二分检索，通常它就取 O(logn)时间。用strcmp比较两个具有n个字符的串需要O(n)时间。常规的矩阵乘算法是O(n^3)，因为算出每个元素都需要将n对
元素相乘并加到一起，所有元素的个数是n^2。
指数时间算法通常来源于需要求出所有可能结果。例如，n个元 素的集合共有2n个子集,所以要求出所有子集的算法将是O(2n)的。指数算法一般说来是太复杂了，除非n的值非常小，因为，在 这个问题中增加一个元素就导致运行时间加倍。不幸的是，确实有许多问题 (如着名的“巡回售货员问题” )，到目前为止找到的算法都是指数的。如果我们真的遇到这种情况，通常应该用寻找近似最佳结果的算法替代之。

8. 如何计算一个算法的时间复杂度

你这个问题是自己想出来的吧？
第一，你指的时间复杂度是大o表示法的复杂度，也就是一个上界，但不是上确界，所以就算你以一种方式中断排序过程，时间复杂度还是o(n*logn)，假设排序过程还能执行的话。
第二，达到o(n*logn)的排序算法，以快速排序为例，快速排序不知道你看过没有，它不像选择排序或者冒泡排序那样，每一趟可以确定一直最大或者最小值，对于快速排序，每一趟排序后如果你删掉最后一个元素将导致整个算法失效。如果你要用这种删除元素方法的话，只能采用冒泡排序或者选择排序，时间复杂度是o(n^2)
所以，我猜想你是不是想做类似于在n个元素中寻找前k个最大者之类的事情（k=n-l）
如果是这样的话，有复杂度是o(n*logk)的算法，利用快速排序中的partition操作
经过partition后，pivot左边的序列sa都大于pivot右边的序列sb；
如果|sa|==k或者|sa|==k-1，则数组的前k个元素就是最大的前k个元素，算法终止;
如果|sa|
k，则从sa中寻找前k大的元素。
一次partition(arr,begin,end)操作的复杂度为end-begin，也就是o(n)，最坏情况下一次partition操作只找到第1大的那个元素，则需要进行k次partition操作，总的复杂度为o(n*k)。平均情况下每次partition都把序列均分两半，需要logk次partition操作，总的复杂度为o(n*logk)。
由于k的上界是n，所以以n表示的总复杂度还是o(n*logn)

9. 请问算法的时间复杂度是怎么计算出来的

首先假设任意一个简单运算的时间都是1，例如a=1;a++;a=a*b;这些运算的时间都是1.

那么例如
for(int i=0;i<n;++i)
{
for(int j=0;j<m;++j)
a++; //注意，这里计算一次的时间是1.
}
那么上面的这个例子的时间复杂度就是 m*n

再例如冒泡排序的时间复杂度是N*N；快排的时间复杂度是log(n)。

详细的情况，建议你看《算法导论》，里面有一章节，具体讲这个的。

10. 算法复杂度的计算

同一个问题可以用不同的算法解决，而一个算竖帆扰法的质量优劣将会影响到算法甚至程序的运行效率。一个算法的好坏主要从时间复杂度和空间复杂度来计算。

    时间复杂度

    一个算法所耗费的时间实际上是不能算出来的，必须上机运行才能知道。但我们也不需要对每个算法都去进行测试，只需要知道哪个算法耗时多，哪个算法耗时少就可以了。一个算法花     费的时间与算法中语句执行的次数成正比，哪个算法中语句执行次数多，它花费时间就多。

    一个算法所耗费的时间=算法中每条语句的执行时间之和

    每条语句的执行时间=语句的执行次数(即频度)×语句执行一次所需时间

    一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),存在一个正常数c使得fn*c>=T(n)恒成立。记作T(n)=O(f(n)),称O(f(n)) 为算法的 渐进时间复杂度。

所以我们可以得出的结论是：算法执行时间可以用执行次数表示。

    空间复杂度

与时间复杂度类似，空间复杂度是指算法在计算机内执行时所需存储空间的度量。记作：

S(n)=O(f(n))

算法执行期间所需要的存储空间包括三个部分：

1.算法程序轿棚所占的空间；

2.输入的初始数据所占的存储空间；

3.算法执行过程中所需要的额外空间。

具体的例子可以余旦参考 十分钟搞定时间复杂度

转自：https://github.com/cttin/cttin.github.io/issues/17