递归算法时间复杂度的递推计算过程。

时间复杂度递推公式
时间复杂度是衡量算法效率的重要指标之一，通常使用大O符号来表示。

在分析算法时间复杂度时，可以使用递推公式来推导出算法的时间复杂度。

时间复杂度递推公式是一种针对算法中基本操作次数的计算方法，它可以帮助我们更加精确地分析算法的时间复杂度。

以递归算法为例，我们可以通过递推公式来分析其时间复杂度。

假设递归函数的时间复杂度为T(n)，则递推公式可以表示为：T(n) = kT(n/m) + f(n)，其中k为递归次数，n/m表示每次递归时问题规模减少的倍数，f(n)为除递归操作外的其他操作的时间复杂度。

通过递推公式，我们可以推导出递归算法的时间复杂度为O(nlogn)。

除了递归算法，我们还可以使用递推公式来分析循环算法的时间复杂度。

以二分查找算法为例，我们可以使用递推公式来推导出其时间复杂度。

假设二分查找算法的时间复杂度为T(n)，则递推公式可以表示为：T(n) = T(n/2) + f(1)，其中f(1)表示每次查找操作的时间复杂度。

通过递推公式，我们可以推导出二分查找算法的时间复杂度为O(logn)。

总之，时间复杂度递推公式是一种重要的算法分析工具，它可以帮助我们更加准确地分析算法的时间复杂度。

在实际应用中，掌握时间复杂度递推公式的使用方法，对于优化算法效率具有重要意义。

- 1 -。

斐波那契数列递归复杂度
斐波那契数列是一个经典的数列，其中每个数都是前两个数的和。

这个数列可以通过递归方式来计算，但是递归算法的时间复杂度是比较高的。

递归算法的时间复杂度可以通过递归树来分析。

对于斐波那契数列的递归算法，递归树如下所示：
fib(n)
/
fib(n-1) fib(n-2)
/ /
fib(n-2) fib(n-3) fib(n-3) fib(n-4)
... ... ...
在递归树中，每个节点代表一次函数调用，每个节点的子节点代表该节点调用的子函数。

在斐波那契数列递归算法中，每个节点会调用两个子函数fib(n-1)和fib(n-2)，因此每个节点会产生两个子节点。

递归算法的时间复杂度可以通过递归树中所有节点的数量来计算。

在斐波那契数列递归算法中，节点数量可以用斐波那契数列的第n个数来表示，即节点数量为fib(n+1)。

因此，递归算法的时间复杂度为O(fib(n+1))。

斐波那契数列的递归算法的时间复杂度非常高，随着n的增加，
时间复杂度增长得非常快。

因此，在实际应用中，一般使用非递归方式来计算斐波那契数列。

算法时间复杂度的计算公式
算法时间复杂度是衡量算法效率的重要指标，它是指算法运行时间随着问题规模的增大而增长的速度。

计算算法时间复杂度需要考虑以下几个因素：
1. 循环结构的次数：算法中循环结构执行的次数是影响时间复杂度的重要因素之一。

2. 嵌套循环结构：如果算法中有多个嵌套循环结构，那么时间复杂度的计算就要考虑这些循环的嵌套次数。

3. 条件判断语句：如果算法中有条件判断语句，那么时间复杂度的计算需要根据条件的判断次数进行计算。

4. 递归调用：如果算法中有递归调用，那么时间复杂度的计算需要根据递归的次数进行计算。

算法时间复杂度的计算公式可以表示为：
T(n) = O(f(n))
其中，T(n)表示算法的时间复杂度，f(n)表示算法执行的时间，O表示算法的渐进时间复杂度。

根据算法的实际情况，可以通过分析算法中循环结构的次数、嵌套次数、条件判断次数、递归次数等因素，来确定算法的时间复杂度。

- 1 -。

fibonacci数列和hanoi塔问题递归算法的时间复杂度【原创实用版】目录一、斐波那契数列的定义和特点二、斐波那契数列的递归算法求解三、递归算法的时间复杂度四、汉诺塔问题及其递归算法求解五、递归算法在斐波那契数列和汉诺塔问题中的应用正文一、斐波那契数列的定义和特点斐波那契数列，又称黄金分割数列、因数数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、55、89、144、233、377、610、987、1597、2584、4181、6765……。

数列中每个数字都是前两个数字之和。

例如，第三个数字是前两个数字之和，即 1+1=2，第四个数字是前两个数字之和，即 1+2=3，以此类推。

二、斐波那契数列的递归算法求解斐波那契数列的递归算法是一种经典的算法，其基本思想是将问题分解为规模较小的相似子问题，然后通过求解子问题来得到原问题的解。

对于斐波那契数列，递归算法的实现如下：1.初始化两个变量，例如 f1 和 f2，分别表示斐波那契数列的第一个和第二个数字。

2.如果要求的数字是第一个或第二个，直接返回对应的数字。

3.否则，计算要求的数字是前两个数字之和，即 f1 + f2，并返回该值。

三、递归算法的时间复杂度递归算法的时间复杂度通常是 O(2^n)，因为每次计算都会将问题规模缩小一半。

然而，在实际应用中，递归算法的效率并不高，因为存在大量的重复计算。

四、汉诺塔问题及其递归算法求解汉诺塔问题是一个经典的递归问题，描述如下：有三根杆子，一根杆子上有三个盘子，分别表示 1、2、3，要求将这三个盘子通过移动，使得目标杆子上的盘子按照 1、2、3 的顺序从上到下排列。

移动过程中，每次只能移动一个盘子，且每个盘子只能按照从上到下的顺序移动。

汉诺塔问题的递归算法实现如下：1.如果当前杆子上只有一个盘子，直接将其移动到目标杆子上。

2.否则，将当前杆子上的最上层盘子移动到目标杆子上，然后递归地处理当前杆子上剩下的两个盘子。

斐波那契数列递归和非递归时间复杂度斐波那契数列是一个非常经典的数列，它的定义如下：F(0)=0F(1)=1F(n)=F(n-1)+F(n-2), (n>=2)斐波那契数列的前几项为：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, …递归算法最常见的实现斐波那契数列的方法是递归。

递归的思想就是将问题拆分成更小的子问题，直到问题变得足够小，可以直接解决。

斐波那契数列的递归实现如下：int fib(int n){if(n<=1)return n;elsereturn fib(n-1)+fib(n-2);}递归算法的时间复杂度递归算法的时间复杂度是非常高的，因为它会重复计算很多相同的值。

具体来说，在计算fib(n)的过程中，会重复计算fib(n-1)和fib(n-2)的值，这样的话，计算时间会随着n的增加而指数级增长。

因此，递归算法的时间复杂度是O(2^n)。

非递归算法除了递归算法外，还有一种更高效的实现斐波那契数列的方法。

这种方法是基于迭代的，可以避免递归算法中重复计算的问题。

具体来说，我们可以用一个数组来存储已经计算过的值，避免重复计算。

非递归算法的实现如下：int fib(int n){int f[n+1];f[0]=0;f[1]=1;for(int i=2;i<=n;i++)f[i]=f[i-1]+f[i-2];return f[n];}非递归算法的时间复杂度非递归算法避免了重复计算，因此可以大大降低计算时间。

具体来说，非递归算法的时间复杂度是O(n)。

这是由于，我们只需要计算一次每个斐波那契数列中的值即可，不需要重复计算。

总结递归算法虽然简单易懂，但是时间复杂度非常高，不适用于大规模计算。

非递归算法则可以有效地避免重复计算，提高计算效率。

因此，在实际的编程中，我们应该尽量使用非递归算法来实现斐波那契数列。

斐波那契数列的递归算法时间复杂度斐波那契数列是一组经典的数字序列，它的构成方式十分简单，就是前两个数字为1，从第三个数字开始，每个数字都是前两个数字之和。

这个数字序列的特点十分有趣，不仅在数学领域具有重大的作用，在计算机科学领域中也是一个重要的议题。

因为它能够用来解决很多实际问题，如序列排序、加密技术、统计分析等问题。

在本篇文章中，我们将从递归算法的角度分析斐波那契数列的时间复杂度。

一、斐波那契数列的递归算法斐波那契数列的递归算法是一种比较简单却耗时较长的算法，其核心思想就是将问题分解成若干个相同的小问题，直到小问题解决后，再依次合并这些小问题的答案得到最终的结果。

我们先来看一下这个算法的代码实现：int fibonacci(int n){if(n == 0 || n == 1){return 1;}else{return fibonacci(n-1) + fibonacci(n-2);}}这个递归算法实现很简单，它的思路就是将求第n位的斐波那契数列转化为求第n-1位和n-2位的斐波那契数列，直到递归到结束条件，就可以得到实际的结果。

对于初学者来说，这种递归算法可能比较容易理解，但实际上这个算法的时间复杂度是很高的，接下来我们将具体分析一下。

二、斐波那契数列递归算法的时间复杂度分析在递归算法中，每次递归都会分解出两个小问题，分别是求n-1位和n-2位的斐波那契数列。

这个过程会一直持续到递归到1或2位数量级，直到递归从底层不断返回结果。

那么，该算法的时间复杂度是多少呢？在斐波那契数列递归算法中，我们发现每次递归都会造成重复计算，因此，每个子问题的复杂度并不简单，实际上每次递归都会花费O(2的n次方)的时间。

由于递归调用次数和指数关联，所以总体时间复杂度是指数级别，也就是O(2的n次方)。

由于指数级别算法的效率非常低，因此，这个算法在实际应用中也就逐渐被淘汰了。

三、斐波那契数列递归算法的空间复杂度分析在递归算法中，空间复杂度指的是函数调用栈所需要的内存空间。

斐波那契递归算法时间复杂度斐波那契数列是一个非常经典的数列，它的第一个数字是 0，第二个数字是 1，从第三个数字开始，每个数字都是前两个数字之和。

例如，斐波那契数列的前10个数字是：0, 1, 1, 2, 3, 5, 8, 13, 21, 34斐波那契数列递归算法是一种经典的算法，它的时间复杂度是O(2^n)，其中 n 是斐波那契数列的第 n 个数字。

这个递归算法的思路是非常简单的，就是利用递归函数来实现斐波那契数列的计算。

具体来说，递归函数可以定义为：int fib(int n) {if (n == 0) {return 0;} else if (n == 1) {return 1;} else {return fib(n-1) + fib(n-2);}}这个递归函数的作用是计算斐波那契数列的第 n 个数字。

如果n 等于 0 或 1，那么直接返回相应的数值即可；否则，递归调用fib(n-1) 和 fib(n-2)，然后将两个结果相加返回。

这个递归算法的时间复杂度是 O(2^n)，因为每次调用 fib 函数，都会产生两个新的递归调用，直到 n 等于 0 或 1 时才返回。

因此，递归调用的次数是 2 的 n 次方减去 1，所以时间复杂度是 O(2^n)。

虽然斐波那契递归算法的时间复杂度很高，但是它仍然有一些优点。

首先，它的实现非常简单，只需要几行代码就可以完成；其次，它的空间复杂度是 O(n)，不需要额外的空间来存储中间结果，因为递归调用会自动保存中间结果。

因此，如果对空间复杂度有限制的情况下，斐波那契递归算法可能是一个不错的选择。

求解递归式，计算时间复杂度⽅法⼀：代换法代换法主要需要以下两个步骤1、猜答案，不需要完全猜出来，不需要知道常熟系数的准确值，⽽只需要猜出它的形式，⽐如猜⼀个递归式的时间复杂度⼤概是O(n2)，即它的运⾏时间应该是⼀个常熟乘以n2，可能还会有⼀些低阶项。

2、⽤数学归纳法证明之，设法求出常数系数可以使问题成⽴例如 T(n)= 4T(n/2) +n ， [T(1) = O(1)]通过观察该递归式，注意到当n加倍时，输出增加4倍，于是猜测该递归式时间复杂度为O(n2)，即T(n) = O(n2) 。

不过直接证明时间复杂度是n2有点困难，可以先从⼀个更简单的开始，⽐如猜测它的时间复杂度是n3，下⾯⽤归纳法证明它。

很显然在n=1的时候是成⽴的，只需要⼀个⽐较⼤的常数就够了。

在⽤归纳法证明过程中是不能使⽤O符号的，所以需要⽤常熟系数展开它，假设T(k) ≤ ck3 (k<n) ，带⼊上⾯递归式，得到T(n) ≤ 4c(n/2)3 + n = 1/2cn3+n = cn3-(1/2cn3-n)≤cn3如果cn3-n≥0可以看到当c≥1,n≥1的时候，该不等式是成⽴的，即T(n)⼩于等于⼀个常数乘以n3,只需要该常数⼤于等于1，这样就得到了⼀个上界，但不是严格意义上的上界，因为我们觉得对于n2它也应该是成⽴的，下⾯开始证明n2的情况，于是抄袭上⾯的步骤再来⼀次，得到T(k) ≤ ck2(k<n)T(n) ≤ 4c(n/2)2 + n =cn2+n= cn2-(-n) 这⼉⽆法得到T(n) ≤cn2 ,假设是错的？囧，看样⼦假设⾥需要⼀个低阶项，于是继续假设T(k) ≤ c1k2-c2k(k<n)T(n) ≤4[c1(n/2)2-c2(n/2)]+n=c1n2+(1-2c2)n = c1n2-c2n-(c2-1)n≤c1n2-c2n 如果c2≥1这样就证明了，对于任意的c1,只要c2⼤于等于1，那么不等式就成⽴。

算法基础（1）之递归、时间空间复杂度参考⽬录：我的笔记：递归（recursion）递归是⼀种很常见的计算编程⽅法，现在通过阶乘案例来学习递归demo1:function factorial(num) {if(num === 1) return num;return num * factorial(num - 1); // 递归求n的阶乘，会递归n次，每次递归内部计算时间是常数，需要保存n个调⽤记录，复杂度 O(n)}const view = factorial(100);console.time(1);console.log(view); // 1: 3.568msconsole.timeEnd(1);递归可能会造成栈溢出，在程序执⾏中，函数通过栈（stack——后进先出）这种数据实现的，每当进⼊⼀个函数调⽤，栈就会增加⼀层栈帧，每次函数返回，栈就会减少⼀层栈帧。

由于栈的⼤⼩不是⽆限的，所以，递归调⽤的次数过多，就会导致栈溢出（stack overflow）。

demo2：尾递归// 如果改为尾递归，只需要保留⼀个调⽤记录，复杂度为O(1)function factorial01(n, tntal) {if(n === 1) return tntalreturn factorial(n - 1, n * tntal) // 把每⼀步的乘积传⼊到递归函数中，每次仅返回递归函数本⾝，total在函数调⽤前就会被计算，不会影响函数调⽤}console.time(2)console.log(factorial01(5, 1)) // 120console.timeEnd(2) // 2: 0.14404296875ms栈帧每⼀个栈帧对应着⼀个未运⾏完的函数，栈帧中保存了该函数的返回地址和局部变量。

栈帧也叫过程活动记录，是编译器⽤来实现过程/函数调⽤的⼀种数据结构。

从逻辑上讲，栈帧就是⼀个函数执⾏的环境：函数参数、函数的局部变量、函数执⾏完后返回到哪⾥等。

递归方程时间复杂度计算递归方程是一种常见的数学形式，用于描述函数自身的定义。

在计算机科学中，递归方程也常用于分析算法的时间复杂度。

通过理解递归方程的含义和解法，我们可以计算出算法的时间复杂度，从而评估算法的效率。

递归方程通常包含两部分：基本情况(base case)和递归情况(recurrence case)。

基本情况是当问题达到最小规模时，可以直接求解的情况。

递归情况是将问题分解为规模更小的子问题，并使用相同的算法求解。

在计算递归算法的时间复杂度时，我们通常采用递归树(recursion tree)的方法。

递归树是通过绘制递归调用的调用树来描述递归算法的执行过程。

每个节点表示一个递归调用，边表示递归调用之间的依赖关系。

要计算递归算法的时间复杂度，我们需要考虑每个递归调用的时间复杂度和递归调用的次数。

基本情况的时间复杂度通常是常数时间复杂度，而递归情况的时间复杂度通常与递归调用的次数和每次调用的规模有关。

下面以几个常见的递归方程为例，介绍如何计算它们的时间复杂度。

1.线性递归方程线性递归方程是指递归只进行一次的情况，形式为T(n)=a*T(n-b)+f(n)，其中a为递归调用的次数，b为每次递归调用时规模的减少量，f(n)为除了递归调用之外的其他操作的时间复杂度。

例如，计算斐波那契数列的算法可以表示为T(n)=T(n-1)+T(n-2)+O(1)。

其中a=2，b=1，f(n)=O(1)。

通过绘制递归树，我们可以看到每个递归调用需要O(1)的时间复杂度，而递归调用的次数为斐波那契数列的第n项，即O(2^n)。

因此，该算法的时间复杂度为O(2^n)。

2.分治递归方程分治递归方程是指递归将问题分解为规模更小的子问题，并使用同样的算法求解的情况。

形式为T(n)=a*T(n/b)+f(n)，其中a为递归调用的次数，b为每次递归调用时规模的减少比例，f(n)为除了递归调用之外的其他操作的时间复杂度。

例如，归并排序的递归方程可以表示为 T(n) = 2 * T(n/2) + O(n)。

实验二递归法求斐波那契数列f(n)的时间复杂度问题描述下载提示：该文档是本店铺精心编制而成的，希望大家下载后，能够帮助大家解决实际问题。

文档下载后可定制修改，请根据实际需要进行调整和使用，谢谢！本店铺为大家提供各种类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，想了解不同资料格式和写法，敬请关注！Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you! In addition, this shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!实验二递归法求斐波那契数列f(n)的时间复杂度问题描述引言在计算机科学中，斐波那契数列是一个经典的数学问题，其定义如下：\[f(0) = 0, f(1) = 1, f(n) = f(n1) + f(n2) \text{ for } n > 1\]本实验旨在探讨使用递归方法求解斐波那契数列时的时间复杂度问题。

c语言全排列递归算法时间复杂度全排列是计算机领域中的一个重要问题，涉及到算法和递归等多种概念。

全排列问题是指将一个集合中的所有元素按照一定的顺序进行排列，使得每个元素都出现一次，且顺序不同视为不同排列。

例如，集合{1, 2, 3}的全排列有6种：{1,2,3}、{1,3,2}、{2,1,3}、{2,3,1}、{3,1,2}和{3,2,1}。

而其它的集合，例如{1,2,3,4}的全排列为24种。

对于一个集合，全排列算法是通过将集合中的元素进行重复选取和交换，以生成不同的排列。

这个过程可以使用递归算法来实现，其中递归函数的作用就是帮助我们在问题空间中移动。

c语言中，全排列递归算法是一个比较经典的例子，其代码实现如下：```cvoid perm(char list[], int i, int n) {int j;if (i == n) { // 结束条件。

for (j = 0; j <= n; j++) {printf("%c ", list[j]);}printf("\n");} else {for (j = i; j <= n; j++) {swap(list[i], list[j]); // 交换元素。

perm(list, i + 1, n); // 递归。

swap(list[i], list[j]); // 回溯。

}}}```这个递归函数的实现思路是：- 以i为起始位置，在给定的字符串list中进行元素交换。

- 对于每次交换，固定其中一个元素，继续递归生成全排列。

- 递归结束后，向前回溯，将已经交换的元素恢复原始状态，等待下一次交换。

接下来，我们来分析一下全排列递归算法的时间复杂度。

时间复杂度全排列算法的最坏时间复杂度为O(n!)，这是因为全排列问题中，每个元素都可能要进行n次交换。

在每次交换的过程中，数组中的元素依次被交换，直到形成所有元素的所有不同组合。

关于递归算法的时间和空间复杂度斐波那契序列：在下⾯的代码中，可以看到函数 fibonacci (int n) 计算了第 n 个斐波那契序列。

斐波那契数列是 0, 1, 1, 2, 3, 5, 8, 13, 21，...。

如你所见，该序列的第0个数为 0，该序列的第1个数为 1，依此类推。

通常，如果 f(n) 表⽰斐波那契数列的第 n 个数字，则 f(n) = f(n-1) + f(n-2) 。

对于此递归关系，f(0) = 0和 f(1) = 1是终⽌条件。

1public int fibonacci(int n) {2if (n == 0 || n == 1) {3return n;4 }56return (fibonacci(n-1) + fibonacci(n-2));7 }时间复杂度：让我们看⼀下⽣成的递归树以计算斐波那契数列的第 5 个数。

在此递归树中，每个状态（除 f(0) 和 f(1) 之外）都会⽣成两个附加状态，并且⽣成的状态总数为 15。

通常，⽤于计算第 n 个斐波那契数 f (n) 的状态总数⼤约等于 2^n。

注意，每个状态都表⽰对 fibonacci(n) 的函数调⽤，该函数除了进⾏另⼀个递归调⽤外不执⾏任何操作。

因此，计算斐波那契数列第 n 个所需的总时间为 O (2^n)。

请注意，这并不总是正确，为了更准确地进⾏时间复杂度分析，应该使⽤主定理。

该解释的⽬的是对递归算法的运⾏时间有⼀个总体了解。

空间复杂度：递归算法的空间复杂度计算有些棘⼿。

我们需要了解如何在内存中⽣成堆栈帧以进⾏递归调⽤序列。

让我们尝试⼤致了解何时⽣成堆栈帧以及它们在内存中保留了多长时间？从⽅法 "f0" 调⽤⽅法 "f1" 时，将创建与该⽅法 "f1" 相对应的堆栈帧。

该堆栈帧将保留在内存中，直到函数 "f1" 的调⽤未终⽌。

公式法求递归算法的时间复杂度例题下载提示：该文档是本店铺精心编制而成的，希望大家下载后，能够帮助大家解决实际问题。

文档下载后可定制修改，请根据实际需要进行调整和使用，谢谢!本店铺为大家提供各种类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，想了解不同资料格式和写法，敬请关注!Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you! In addition, this shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!公式法求递归算法的时间复杂度引言在计算机科学中，递归算法是一种重要的算法设计技术，它通过将问题分解为更小的子问题来解决问题。

递归算法时间复杂度【代⼊法】代⼊法⾸先要对这个问题的时间复杂度做出预测，然后将预测带⼊原来的递归⽅程，如果没有出现⽭盾，则是可能的解，最后⽤数学归纳法证明。

【举例】我们有如下的递归问题：T(n)=4T(n/2)+O(n)，我们⾸先预测时间复杂度为O(n2),不妨设T(n)=kn2（其中k为常数），将该结果带⼊⽅程中可得：左=kn2，右=4k(n/2)2+O(n)=kn2+O(n),由于n2的阶⾼于n的阶，因⽽左右两边是相等的，接下来⽤数学归纳法进⾏验证即可。

【迭代法】迭代法就是迭代的展开⽅程的右边，直到没有可以迭代的项为⽌，这时通过对右边的和进⾏估算来估计⽅程的解。

⽐较适⽤于分治问题的求解，为⽅便讨论起见，给出其递归⽅程的⼀般形式： 【举例】下⾯我们以⼀个简单的例⼦来说明：T(n)=2T(n/2)+n2,迭代过程如下： 容易知道，直到n/2^(i+1)=1时，递归过程结束，这时我们计算如下： 到这⾥我们知道该算法的时间复杂度为O(n2)，上⾯的计算中，我们可以直接使⽤⽆穷等⽐数列的公式，不⽤考虑项数i的约束，实际上这两种⽅法计算的结果是完全等价的，有兴趣的同学可以⾃⾏验证。

【公式法】这个⽅法针对形如：T(n) = aT(n/b) + f(n)的递归⽅程。

这种递归⽅程是分治法的时间复杂性所满⾜的递归关系，即⼀个规模为n的问题被分成规模均为n/b的a个⼦问题，递归地求解这a个⼦问题，然后通过对这a个⼦问题的解的综合，得到原问题的解。

这种⽅法是对于分治问题最好的解法，我们先给出如下的公式： 公式记忆：我们实际上是⽐较n^log b a和f(n)的阶，如果他们不等，那么T(n)取他们中的较⼤者，如果他们的阶相等，那么我们就将他们的任意⼀个乘以logn就可以了。

按照这个公式，我们可以计算【迭代法】中提到的例⼦：O(f(n))=O(n2),容易计算另外⼀个的阶是O(n),他们不等，所以取较⼤的阶O(n2)。

算法计算时间复杂度（1）：求递归式f（n）=2f（n2）+n当 n = 1 时，f(n) = 1;当 n > 1 时，f(n) = 2*f(n/2) + n ；求f(n)的递归式⾸先为什么要求递归式呢？是因为在计算机中有些算法是使⽤递归⽅式实现，我们需要计算该递归⽅式的时间复杂度，来评定算法的优劣。

下⾯我们来求f(n)的递归式，什么是递归式呢？就是等号左边只有f(n),等号右边只有关于n的表达式。

看到f(n) = 2*f(n/2) + n 这个式⼦你想到了什么，是不是将f(n/2)变掉。

如何将f(n/2) 变掉呢？可以假设 n = 2k ，那么 f(n) = f(2k) 然后假设 f(2k) = h(k), f(n/2) = f(k) = h(k/2) 显然这么做毫⽆意义。

也可以假设 n = 2^k ,那么 f(n) = f(2^k) 然后假设 f(2^k) = h(k), f(n/2) = f(2^(k-1)) = h(k-1)。

那么 f(n) = 2*f(n/2) + n => h(k) = 2*h(k-1) + 2^k ;另外 n = 1 时，f(n) = 1 ，1 = 2^k => k = 0 时 h(k) = 1 ;换句话说就是将当 n = 1 时，f(n) = 1;当 n > 1 时，f(n) = 2*f(n/2) + n ；=>n = 2^k ；当 k = 0 时 h(k) = 1 ;当 k > 0 时 h(k) = 2*h(k-1) + 2^k ；h(1) = 2*h(0) + 2^1h(2) = 2*h(1) + 2^2h(3) = 2*h(2) + 2^3h(3）= 2*(2*h(1) + 2^2) + 2^3= 2^2 * h(1) + 2^3 + 2^3= 2^2 * (2*h(0) + 2^1) + 2^3 + 2^3= 2^3 * h(0) + 2^3 + 2^3 + 2^3= 4 * 2^3h(k) = 2^k * h(0) + k * (2^k)= (k + 1) * 2^k我们得到了 h(k) = (k + 1) * 2^k ,因为 n = 2^k => k = log2 n , f(n) = h(k)f(n) = (log2 n + 1) * 2^log2 n= (log2 n + 1) * n= n * log2 n + n于是得到了 f(n) = n * log2 n + n 。