求解时间复杂度的方法有很多，之前我们学过使用递推公式计算时间复杂度，今天我们就来学习用递归树来求解递归算法的时间复杂度。
递归树与时间复杂分析
递归树
递归的思想是将大问题不断分解成小问题来解决，如果我们把递归一层一层的分解过程画成图，它其实就是一棵树，这种树就叫做递归树，下面就是求斐波那契数列的递归树：
用递归树求解时间复杂度
我将求解时间复杂度的过程分为以下几部分：构建递归树、分析每一层的主要操作（得到每一层的时间复杂度）、分析高度、计算复杂度。
构建递归树
这里用归并排序作为例子，根据归并排序算法的操作，数据每次会被一分为二。我们把归并排序画成递归树：
分析递归层
在归并排序中，将数组一分为二的代价很低，真正耗费时间的操作是merge函数（合并操作），之前的学习中我们知道，如果两个数组的数据个数都为 n ，合并操作的时间复杂度为 n + n = 2n。由此我们可以总结出每一个递归层需要耗费的时间复杂度为 n 。
分析高度
经过分析，可以很容易地算出归并排序的递归树的高度越为 logn。
计算求复杂度
假设一棵树的高度为 h，用高度 h 乘以每一层的时间消耗 n，就可以得到算法整体的时间复杂度O(n*h)。根据之前的分析，我们可以计算出递归排序算法的时间复杂度为O(nlogn)。
当然，这种分析方法不一定精确，但是正如之前我们说的，算法的时间复杂度主要表示算法随数据量的变化的变化趋势即可，因此分析到这里就已经足够了。
几个分析案例
分析快速排序的时间复杂度
构建递归树
在快速排序的学习中，我们知道如果快速排序的每一次分区都将数据平均分成两份，那么它的时间复杂度很容易就可以计算出来。那如果我们将每一次的分割比例设置成为 k:1 ,又该怎么计算呢？
分析递归层
快排的过程中，每次分区都要遍历待分区区间的所有数据，所以每一层递归的主要操作就是对数据的遍历操作，操作次数为 n 。
分析高度
快速排序的结束条件是待排序区间的大小为 1 ，也就是说叶子节点中的数据规模是 1 。从根节点到叶子节点，最短路径是每次数据规模乘以 1/10 ，最常路径是每次数据规模乘以 9/10，经过计算，我们可以得到路径长度：
经过计算，可以得到递归树的高度在 最短路径 和 最常路径之间，根据复杂度的大O标识法，我们同一当做logn。
计算复杂度
很简单，复杂度为 O(nlogn)。
你可以思考一下，我们假设 k=9 ,如果 k 为，99、999 又会是什么情况？没错，只要 k 不随 n 的变化而变化，它的时间复杂度都是O(nlogn)。
分析求斐波那契数列的时间复杂度
递归树
分析递归层
斐波那契数列的递推公式为：
int f(int n) {
if (n == 1) return 1;
if (n == 2) return 2;
return f(n-1) + f(n-2);
}
你会发现，在每一层的递推中，主要操作是 f(n-1) + f(n-2) 的加法操作。这也就是说，每一层的主要操作来自这个加法操作，如果一层只分解一个函数，复杂度为 1 ，分解两个函数，复杂度为 2...最终可以得到，第 k 层的时间消耗是 2k-1。
分析高度
f(n) = f(n-1) + f(n-2),根据这个公式我们看出每次递归的数据规模都是 -1 或者 -2 ，叶子节点的数据规模为 1 或者 2 。如果每次数据规模都 -1 ，路径长度为 n ;如果每次数据规模 -2 ，路径长度为 n/2。前者是最常路径，后者的最短路径。
计算复杂度
这个例子求解复杂度的方法和之前的例子不同，前面的例子在每一个递归层的复杂度都是 n ，而这个例子的复杂度随着层的深入复杂度也在增加，所以我们不能简单地 n * k。而是要将每一层的复杂度相加。
假设路径长度为n：
所以，这个算法的时间复杂度介于 O(2n) 和 O(2n/2) 之间。不论真正的复杂度指数为多少，但是我们已经了解到它的时间复杂度是指数级的，这非常高。
分析全排列的时间复杂度
全排列问题：假设有三个数字 1，2，3，它们的全排列有：
1, 2, 3
1, 3, 2
2, 1, 3
2, 3, 1
3, 1, 2
3, 2, 1
递归树
仔细思考，你可以将这个问题利用递归实现，递归的语言描述是这样的：“n 个数据的排列”问题，就可以分解成 n 个“n-1 个数据的排列”的子问题。
递推公式如下：
假设数组中存储的是1，2， 3...n。
f(1,2,...n) = {最后一位是1, f(n-1)} + {最后一位是2, f(n-1)} +...+{最后一位是n, f(n-1)}。
代码如下：
// 调用方式：
// int[]a = a={1, 2, 3, 4}; printPermutations(a, 4, 4);
// k表示要处理的子数组的数据个数
public void printPermutations(int[] data, int n, int k) {
if (k == 1) {
for (int i = 0; i < n; ++i) {
System.out.print(data[i] + " ");
}
System.out.println();
}
for (int i = 0; i < k; ++i) {
int tmp = data[i];
data[i] = data[k-1];
data[k-1] = tmp;
printPermutations(data, n, k - 1);
tmp = data[i];
data[i] = data[k-1];
data[k-1] = tmp;
}
}
分析递归层
根据给出的递归代码，可以得出主要操作是数据交换操作。
第一层有 1 个节点，节点数据规模为 n，故每个节点需要 n 次交换操作。故该层一共进行 n 次操作；
第二层有 n 个节点，节点数据规模为 n-1，故每个节点需要 n-1 次交换操作。故该层一共进行 n*(n-1) 次操作；
第三层有 n*(n-1) 个节点，节点数据规模为 n-2 ，故每个节点要 n-2 次操作。故该层一共进行 n * (n-1) * (n-2) 次操作。
...
最后一层为要进行 n*(n-1)*...*2 *1 次操作，也就是 n! 次操作。
分析高度
根据递推公式，每一次数据规模 -1 ，所以递归树的高度为 n 。
计算复杂度
最后一层的时间复杂度为 O(n!)，所以时间复杂度一定会高于 O(n!)；
最后一层的时间复杂度在各层中是最高的，所以我们可以判定，数据为 n （递归深度也n）的全排列的时间复杂度小于 O(n*n!)。
复杂度计算差不多到这里就可以了，因为 O(n!) 的复杂度是极其去巨大的。
总结
使用递归树分析算法的时间复杂度可以分为以下四个步骤：
得到递归树：根据递归算法给出的递推公式，我们可以获得递归树。
对递归层进行分析：分析递推公式和递归函数，明确在一个递归层中，什么操作是最后主要的操作（执行次数最多的操作）。并计算在第 k 层中要进行多少次这样的操作（该层的时间复杂度）。
对递归深度（递归树的高度）的分析：分析递推公式，根据数据规模缩小的趋势可以很容易地算出来。
计算时间复杂度：对每一层的时间复杂度进行累加，所求的和就是该算法的时间复杂度。
以上就是使用递归树分析递归算法的时间复杂度的全部内容
注：本文章的主要内容来自我对极客时间app的《数据结构与算法之美》专栏的总结，我大量引用了其中的代码和截图，如果想要了解具体内容，可以前往极客时间
