递归

前言

由于是第一次正式写文章，还有所不足。这里想分享的是力扣刷题过程中，遇到的一些算法问题。希望通过写文章来加深自身印象以及总结。网上的类似经验分享很多，这里我只根据自身实际情况进行探讨。在力扣刷题过程中，常遇到的算法应用不外乎递归、迭代、分治、回溯、动态规划，接下来将一一对它们进行分析阐述。这里讲的是递归。

一、递归是什么？

递归的官方定义是直接或间接调用自身的算法。
递归需要注意的有两点：
1.递归需要在过程和函数里面调用自身；
2.递归需要一个递归结束条件，也就是递归出口。
递归分为两个阶段：
1.递推：把复杂的问题的求解推到比原问题简单一些的问题的求解。
2.回归：当获得最简单的情况后，逐步返回，得到复杂的解。
有关递归的问题有：斐波那契数列，汉诺塔问题，背包问题。
递归的优缺点：
优点：结构清晰，简单，可用数学归纳法证明
缺点：
1.需要一个递归栈来存在函数的变量和结果，空间复杂度增加。
2.可能会出现重复计算的问题，从而影响时间复杂度
这在算法设计里是很致命的，所以需要根据情况来使用递归算法。

1.实例

下面将举三个实例，从简单、中等到困难来一一探讨递归问题。

实例1：给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
解析：根据数据结构所学相关知识，不难明白可以用递归算法来进行求解。
这里给出力扣官方的两种解题思路，对此进行具体阐述。

方法一：自顶向下的递归

定义函数height，用于计算二叉树中的任意一个节点 p 的高度：

有了计算节点高度的函数，即可判断二叉树是否平衡。具体做法类似于二叉树的前序遍历，即对于当前遍历到的节点，首先计算左右子树的高度，如果左右子树的高度差是否不超过 11，再分别递归地遍历左右子节点，并判断左子树和右子树是否平衡。这是一个自顶向下的递归的过程。

代码如下所示：

class Solution {
    public boolean isBalanced(TreeNode root) {
        if (root == null) {
            return true;
        } else {
            return Math.abs(height(root.left) - height(root.right)) <= 1 && isBalanced(root.left) && isBalanced(root.right);
        }
    }
    public int height(TreeNode root) {
        if (root == null) {
            return 0;
        } else {
            return Math.max(height(root.left), height(root.right)) + 1;
        }
    }
}

复杂度分析：
1.时间复杂度O(n^2),其中n是二叉树结点个数。
最坏情况下，二叉树是满二叉树，需要遍历二叉树中的所有节点，时间复杂度是 O(n)。
对于节点 p，如果它的高度是 d，则height§ 最多会被调用 d 次（即遍历到它的每一个祖先节点时）。对于平均的情况，一棵树的高度 h 满足 O(h)=O(logn)，因为d≤h，所以总时间复杂度为O(nlogn)。对于最坏的情况，二叉树形成链式结构，高度为 O(n)，此时总时间复杂度为 O(n^2)。
2，空间复杂度O(n)，其中 n 是二叉树中的节点个数。空间复杂度主要取决于递归调用的层数，递归调用的层数不会超过 n。

方法二:自底向上的递归

方法一由于是自顶向下递归，因此对于同一个节点，函数 height 会被重复调用，导致时间复杂度较高。如果使用自底向上的做法，则对于每个节点，函数height 只会被调用一次。
自底向上递归的做法类似于后序遍历，对于当前遍历到的节点，先递归地判断其左右子树是否平衡，再判断以当前节点为根的子树是否平衡。如果一棵子树是平衡的，则返回其高度（高度一定是非负整数），否则返回 -1。如果存在一棵子树不平衡，则整个二叉树一定不平衡。

代码如下所示：

class Solution {
    public boolean isBalanced(TreeNode root) {
        return height(root) >= 0;
    }

    public int height(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = height(root.left);
        int rightHeight = height(root.right);
        if (leftHeight == -1 || rightHeight == -1 || Math.abs(leftHeight - rightHeight) > 1) {
            return -1;
        } else {
            return Math.max(leftHeight, rightHeight) + 1;
        }
    }
}

复杂度分析
1.时间复杂度：O(n)，其中 n 是二叉树中的节点个数。使用自底向上的递归，每个节点的计算高度和判断是否平衡都只需要处理一次，最坏情况下需要遍历二叉树中的所有节点，因此时间复杂度是 O(n)。
2.空间复杂度：O(n)，其中 nn 是二叉树中的节点个数。空间复杂度主要取决于递归调用的层数，递归调用的层数不会超过 n。

实例2：给定一个二叉树，判断它是否是高度平衡的二叉树。
返回包含 N 个结点的所有可能满二叉树的列表。 答案的每个元素都是一个可能树的根结点。答案中每个树的每个结点都必须有 node.val=0。你可以按任何顺序返回树的最终列表。

方法：递归

思路与算法
令FBT(N) 作为所有含 N 个结点的可能的满二叉树的列表。
每个满二叉树 TT 含有 3 个或更多结点，在其根结点处有 2 个子结点。这些子结点 left 和 right 本身就是满二叉树。
因此，对于N≥3，我们可以设定如下的递归策略：FBT(N)= [对于所有的 x，所有的树的左子结点来自 FBT(x) 而右子结点来自FBT(N−1−x)]。
此外，通过简单的计数参数，没有满二叉树具有正偶数个结点。
最后，我们应该缓存函数FBT之前的结果，这样我们就不必在递归中重新计算它们。

class Solution {
    Map<Integer, List<TreeNode>> memo = new HashMap();

    public List<TreeNode> allPossibleFBT(int N) {
        if (!memo.containsKey(N)) {
            List<TreeNode> ans = new LinkedList();
            if (N == 1) {
                ans.add(new TreeNode(0));
            } else if (N % 2 == 1) {
                for (int x = 0; x < N; ++x) {
                    int y = N - 1 - x;
                    for (TreeNode left: allPossibleFBT(x))
                        for (TreeNode right: allPossibleFBT(y)) {
                            TreeNode bns = new TreeNode(0);
                            bns.left = left;
                            bns.right = right;
                            ans.add(bns);
                        }
                }
            }
            memo.put(N, ans);
        }

        return memo.get(N);
    }
}

复杂度分析
1.时间复杂度：O(2^N)，对于N是奇数的情况，令 N = 2k + 1。然后，
| FBT(N) | = Ck ，第 k个卡特兰数（Catalan Number）；以及
∑Ck（计算中间结果所涉及的复杂度） 限制在 O(2^N)内。但是，证明超出了本文的范围。
2.空间复杂度：O(2^N )。

实例3：二叉树的最大路径和，给定一个非空二叉树，返回其最大路径和。
本题中，路径被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。

总结

通过本次博客总结，了解了递归的相关知识以及递归的具体过程，最终通过力扣算法题从实际上了解了递归的应用问题。