两种递归形式及时空复杂度分析

以二叉树为例说明递归，并用二叉树的最大深度为例说明两种递归方式的区别。

1、自底向上的递归

（1）这种递归方式类似于"二叉树的后序遍历"。
（2）在每个递归层次上，我们首先对所有子节点递归地调用函数，然后根据返回值和根节点本身的值得到答案。
（3）“自底向上” 的递归函数 bottom_up(root) 为如下所示：

return specific value for null node
left_ans = bottom_up(root.left)			// call function recursively for left child
right_ans = bottom_up(root.right)		// call function recursively for right child
return answers                           // answer <-- left_ans, right_ans, root.val

（4）二叉树的最大深度：

1. 分析：对于树的单个节点，以节点自身为根的子树的最大深度x是多少？我们知道一个根节点，以其左子节点为根的最大深度为l和以其右子节点为根的最大深度为r，然后选择它们之间的最大值，再加上1来获得根节点所在的子树的最大深度。 那就是 x = max（l，r）+ 1。
2. 图示：（从叶子节点开始，从下往上）
   
3. 代码：

    // 自底向上的递归
    int maxDepth(TreeNode* root) {
        if(nullptr==root) return 0;
        // 类似于后序遍历（左子树--->右子树---->根节点）
        int left_res = maxDepth(root->left);
        int right_res = maxDepth(root->right);
        return max(left_res,right_res)+1;
    }

2、自顶向下的递归

（1）“自顶向下” 意味着在每个递归层级，我们将首先访问节点来计算一些值，并在递归调用函数时将这些值传递到子节点。
（2） “自顶向下” 的解决方案可以被认为是一种前序遍历。
（3）递归函数 top_down(root, params) 的原理是这样的：

return specific value for null node
update the answer if needed                      // answer <-- params
left_ans = top_down(root.left, left_params)		// left_params <-- root.val, params
right_ans = top_down(root.right, right_params)	// right_params <-- root.val, params
return the answer if needed                      // answer <-- left_ans, right_ans

（4）二叉树的最大深度：

1. 分析：我们知道根节点的深度是1。 对于每个节点，如果我们知道某节点的深度，那我们将知道它子节点的深度。 因此，在调用递归函数的时候，将节点的深度传递为一个参数，那么所有的节点都知道它们自身的深度。 而对于叶节点，我们可以通过更新深度从而获取最终答案。
2. 图示：（从根节点出发，向下递归，每次走到叶子节点的时候更新答案）
   
3. 代码

class Solution {
public:
    // 自顶向下的递归
    int res = 0;
    int maxDepth(TreeNode* root) {
        if(nullptr==root) return 0;
        maxDepth(root,1);
        return res;
    }    
    void maxDepth(TreeNode* root,int depth){
        if(nullptr==root) return;
        // 类似于前序遍历
        if(nullptr==root->left && nullptr==root->right){
            res = max(res,depth);
        }
        maxDepth(root->left,depth+1);
        maxDepth(root->right,depth+1);
    }
}

3、时间和空间复杂度

（路径总和）：给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。

bool hasPathSum(TreeNode* root, int targetSum) {
    if(nullptr==root) return false;
    if(root->left==nullptr && root->right==nullptr && root->val==targetSum ) return true;
    return hasPathSum(root->left,targetSum-(root->val)) || hasPathSum(root->right,targetSum-(root->val));
    }

(1) 时间复杂度

子问题的个数乘以解决一个子问题所需要的时间。（子问题的个数就是递归树中节点的总数）。

时间复杂度：O(N)，其中 N 是树的节点数。

(2)空间复杂度

空间复杂度主要取决于递归时栈空间的开销，最坏情况下，树呈现链状，空间复杂度为 O(N)。平均情况下树的高度与节点数的对数正相关，空间复杂度为 O(logN)。

空间复杂度：O(H)，其中 H 是树的高度。 

4、主定理

（1）主定理主要是用分治方法带来的递归表达式的渐近复杂度分析。
（2）描述：规模为n的问题通过分治，得到a个规模为n/b的问题，每次递归带来的额外计算为O(n^d)，d=log_ba。
则：
T(n) = O(log(n)*n^d) ,if a = b^d(1)
T(n) = O(n^d), if a < b^d(2)
T(n) = O(n^log_ba), if a > b^d(3)

例如：

（BST的搜索）：给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。

// 递归
TreeNode searchBST(TreeNode* root, int val) {
    if (root == nullptr || val == root->val) return root;
    return val < root->val ? searchBST(root->left, val) : searchBST(root->right, val);
}

（1）时间复杂度
在二叉搜索中，每次分解后只有一个子问题 a = 1，其规模为初始问题的一半 b = 2，每次分解花费恒定时间O(1)，因此d=0。则根据（1）式得log(n).
时间复杂度：O(H)，其中 H 是树高。平均时间复杂度为O(logN)，最坏时间复杂度为 O(N)。
（2）空间复杂度
空间复杂度：O(H)，递归栈的深度为 H。平均情况下深度为O(logN)，最坏情况下深度为O(N)。