递归算法时间复杂度怎么算（n个碟子汉诺塔递归问题的时间复杂度是）

本文目录

• n个碟子汉诺塔递归问题的时间复杂度是
• 由递归方式求的N的阶乘（即N，），时间复杂度是多少
• 时间复杂度o(nlogn)的算法是什么
• 怎么将C语言递归算法转化成“递归方程”该种算法时间的复杂度怎么求有固定的方法吗
• 时间复杂度是多少
• 怎么估算一个算法的时间复杂度
• 递归函数的时间复杂度应该怎么算

n个碟子汉诺塔递归问题的时间复杂度是

汉诺塔问题的时间复杂度为O(2^n)。

时间复杂度的计算：用递归来解决汉诺塔问题是非常方便的选择。

设盘子个数为n时，需要T(n)步，把A柱子n-1个盘子移到B柱子，需要T(n-1)步，A柱子最后一个盘子移到C柱子一步，B柱子上n-1个盘子移到C柱子上T(n-1)步。

得递推公式T(n)=2T(n-1)+1。

所以，汉诺塔问题的时间复杂度为O(2^n)。

扩展资料

递归算法要求

递归算法所体现的“重复”一般有三个要求：

1、每次调用在规模上都有所缩小（通常是减半）。

2、相邻两次重复之间有紧密的联系，前一次要为后一次做准备(通常前一次的输出就作为后一次的输入)。

3、在问题的规模极小时必须用直接给出解答而不再进行递归调用，因而每次递归调用都是有条件的（以规模未达到直接解答的大小为条件），无条件递归调用将会成为死循环而不能正常结束。

由递归方式求的N的阶乘（即N，），时间复杂度是多少

每次递归内部计算时间是常数，故O（n）。

用递归方法计算阶乘，函数表达式为f(n)=1 若n=0 f(n)=n*f(n-1)，若n》0，如果n=0，就调用1次阶乘函数，如果n=1，就调用2次阶乘函数，如果n=2，就调用3次阶乘函数，如果n=3，就调用4次阶乘函数。

扩展资料：

注意事项：

利用递归树方法求算法复杂度，其实是提供了一个好的猜测，简单而直观。在递归树中每一个结点表示一个单一问题的代价，子问题对应某次递归函数调用，将树中每层中的代价求和，得到每层代价，然后将所有层的代价求和，得到所有层次的递归调用总代价。

递归树最适合用来生成好的猜测，然后可用代入法来验证猜测是否正确。当使用递归树来生成好的猜测时，常常要忍受一点儿不精确，因为关注的是如何寻找解的一个上界。

参考资料来源：百度百科-递归算法

参考资料来源：百度百科-阶乘

参考资料来源：百度百科-时间复杂度

时间复杂度o(nlogn)的算法是什么

时间复杂度o(nlogn)的算法是采用“分治思想”，将要排序的数组从中间分成前后两个部分，然后对前后两个部分分别进行排序，再将排序好的两部分合并在一起，这样数组就有序。

每次划分区域都选择中间点进行划分，所以递归公式可以写成：T(n) = T(n/2) + T(n/2) + n， T(1) = C(常数)    //每次合并都要调用Merge()函数，时间复杂度为O(n)，等价T(n) = 2kT(n/2k) + k * n， 递归的最终状态为T(1)即n/2k = 1，所以k = log2n。

原理分析：

1、运用了分治的思想。选取分区值，将待排序列分为两个前后两部分，前部分数据元素的值小于等于分区值，后部分的数据元素的值大于等于分区值；继续对前后两部分分别进行分区，直到分区大小为1。

2、交换操作的执行次数可以由时间复杂度分析过程得出，Merge()中总的交换次数为n * logn，因为不管两个子序列的大小，子序列中的各个元素都会先放入临时数组temp中，再重新放回原序列；比较操作的次数小于等于交换操作次数，最大交换次数为n * logn。

怎么将C语言递归算法转化成“递归方程”该种算法时间的复杂度怎么求有固定的方法吗

不知道你是怎么得出“递归算法可以转化成方程“这个结论的呢? 如果真是这样,那么世界上恐怕很多NP问题都可以解决了. 深度优先搜索很多时候就是递归结构的,但是并没有什么办法将其转化成方程解决.

我猜想也许你说的是很特殊的一类递归问题,这类递归问题可以用数学函数来表达.例如计算阶乘的时候,n! = (n-1)*n. 那这个是怎么的出来的就真没有固定的套路,但是一般的思想是考虑如何把一个问题转化成规模更小的几个问题.

时间复杂度是多少

时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数
该程序
S=0; -------这里是常数O(1),
for(i=0;i《n;i++)
for(j=0;j《n;j++)
s+=b[i][j]; ----这里是n的平方，用平方阶表示O(n^2)
sum = s;-------这里是常数O(1)
所以上述时间复杂度是T(n) = 两个常数O(1) + n的平方，两个常数相对n的平方来说是低阶项去掉，即常数阶可以去掉忽略不计。
最终时间复杂度是T(n) = O(n^2)

怎么估算一个算法的时间复杂度

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

(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) 《 cn2 - eO(2n)（注意，这里减去O(2n)，因其是低阶项，不会影响到n足够大时的渐近性），把这个解代入递归方程，得到：

T(n) = 4T(n/2) + O(n)
≤ 4c(n/2)2 - eO(2n/2)) + O(n)
= cn2 - eO(n) + O(n)
≤ cn2

其中，c为正常数，e取1，上式符合 T(n)≤cn2 的定义，则可认为O(n2 )是T(n)的一个解，再用数学归纳法加以证明。

二、迭代法

某算法的计算时间为：T(n) = 3T(n/4) + O(n)，其中T(1) = O(1)，迭代两次可将右端展开为：

T(n) = 3T(n/4) + O(n)
= O(n) + 3( O(n/4) + 3T(n/42 ) )
= O(n) + 3( O(n/4) + 3( O(n/42 ) + 3T(n/43 ) ) )

从上式可以看出，这是一个递归方程，我们可以写出迭代i次后的方程：

T(n) = O(n) + 3( O(n/4) + 3( O(n/42 ) + ... + 3( n/4i + 3T(n/4i+1 ) ) ) )

当n/4i+1 =1时，T(n/4i+1 )=1，则

T(n) = n + (3/4) + (32 /42 )n + ... + (3i /4i )n + (3i+1 )T(1)
《 4n + 3i+1

而由n/4i+1 =1可知，i《log4 n，从而

3i+1 ≤ 3log4 n+1 = 3log3 n*log4 3 +1 = 3nlog4 3

代入得：

T(n) 《 4n + 3nlog4 3，即T(n) = O(n)。

三、套用公式法

这个方法为估计形如：

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

其中，a≥1和b≥1，均为常数，f(n)是一个确定的正函数。在f(n)的三类情况下，我们有T(n)的渐近估计式：

1.若对于某常数ε》0，有f(n) = O(nlogb a-ε )，则T(n) = O(nlogb a )

2.若f(n) = O(nlogb a )，则T(n) = O(nlogb a *logn)

3.若f(n) = O(nlogb a+ε )，且对于某常数c》1和所有充分大的正整数n，有af(n/b)≤cf(n)，则T(n)=O(f(n))。

设T(n) = 4T(n/2) + n，则a = 4，b = 2，f(n) = n，计算得出nlogb a = nlog2 4 = n2 ，而f(n) = n = O(n2-ε )，此时ε= 1，根据第1种情况，我们得到T(n) = O(n2 )。

这里涉及的三类情况，都是拿f(n)与nlogb a 作比较，而递归方程解的渐近阶由这两个函数中的较大者决定。在第一类情况下，函数nlogb a 较大，则T(n)=O(nlogb a )；在第三类情况下，函数f(n)较大，则T(n)=O(f (n))；在第二类情况下，两个函数一样大，则T(n)=O(nlogb a *logn)，即以n的对数作为因子乘上f(n)与T(n)的同阶。

但上述三类情况并没有覆盖所有可能的f(n)。在第一类情况和第二类情况之间有一个间隙：f(n)小于但不是多项式地小于nlogb a ，第二类与第三类之间也存在这种情况，此时公式法不适用。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/metasearch/archive/2009/08/09/4428865.aspx

递归函数的时间复杂度应该怎么算

求解算法的时间复杂度的具体步骤是：
　　⑴ 找出算法中的基本语句；
　　算法中执行次数最多的那条语句就是基本语句，通常是最内层循环的循环体。
　　⑵ 计算基本语句的执行次数的数量级；
　　只需计算基本语句执行次数的数量级，这就意味着只要保证基本语句执行次数的函数中的最高次幂正确即可，可以忽略所有低次幂和最高次幂的系数。这样能够简化算法分析，并且使注意力集中在最重要的一点上：增长率。
　　⑶ 用大Ο记号表示算法的时间性能。
　　将基本语句执行次数的数量级放入大Ο记号中。
　　如果算法中包含嵌套的循环，则基本语句通常是最内层的循环体，如果算法中包含并列的循环，则将并列循环的时间复杂度相加。例如：
　　for (i=1; i《=n; i++)
　　x++;
　　for (i=1; i《=n; i++)
　　for (j=1; j《=n; j++)
　　x++;
　　第一个for循环的时间复杂度为Ο(n)，第二个for循环的时间复杂度为Ο(n2)，则整个算法的时间复杂度为Ο(n+n2)=Ο(n2)。
　　常见的算法时间复杂度由小到大依次为：
　　Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜…＜Ο(2n)＜Ο(n!)
Ο(1)表示基本语句的执行次数是一个常数，一般来说，只要算法中不存在循环语句，其时间复杂度就是Ο(1)。Ο(log2n)、Ο(n)、Ο(nlog2n)、Ο(n2)和Ο(n3)称为多项式时间，而Ο(2n)和Ο(n!)称为指数时间。计算机科学家普遍认为前者是有效算法，把这类问题称为P类问题，而把后者称为NP问题。
这只能基本的计算时间复杂度，具体的运行还会与硬件有关。
参考博客地址：