LeetCode-Python 递归专题（学习笔记+代码）

最新推荐文章于 2024-04-24 21:16:44 发布

故里_

最新推荐文章于 2024-04-24 21:16:44 发布

阅读量537

点赞数

分类专栏： LeetCode 文章标签： leetcode python 学习

本文链接：https://blog.csdn.net/lht0909/article/details/124350822

版权

LeetCode 专栏收录该内容

6 篇文章 3 订阅

订阅专栏

文章目录

LeetCode70. 爬楼梯
LeetCode50. Pow(x, n)
LeetCode22. 括号生成
LeetCode129. 求根节点到叶节点数字之和

LeetCode70. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2

解释：有两种方法可以爬到楼顶。

1 阶 + 1 阶
2 阶

示例 2：

输入：n = 3
输出：3

解释：有三种方法可以爬到楼顶。

1 阶 + 1 阶 + 1 阶
1 阶 + 2 阶
2 阶 + 1 阶

# f(n)只依赖于f(n-1)和f(n-2)，只需要两项就足够了
def climbStairs(self, n: int) -> int:
    a = b = 1
    for i in range(2, n + 1):
        a, b = b, a + b
    return b

LeetCode50. Pow(x, n)

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn ）。

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000

示例 2：

输入：x = 2.10000, n = 3
输出：9.26100

示例 3：

输入：x = 2.00000, n = -2
输出：0.25000

解释：2-2 = 1/22 = 1/4 = 0.25

class Solution(object):
    def myPow(self, x, n):
        """
        :type x: float
        :type n: int
        :rtype: float
        """
        if n == 0:
            return 1
        if n < 0:
            x = 1 / x
            n = -n
        if n % 2:
            return x * self.myPow(x, n - 1)
        return self.myPow(x * x, n / 2)

LeetCode22. 括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。

示例 1：

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

示例 2：

输入：n = 1
输出：["()"]

解题思路

在这里插入图片描述

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        if n <= 0: return []
        res = []

        def dfs(paths, left, right):
            if left > n or right > left: return
            if len(paths) == n * 2:  # 因为括号都是成对出现的
                res.append(paths)
                return

            dfs(paths + '(', left + 1, right)  # 生成一个就加一个
            dfs(paths + ')', left, right + 1)

        dfs('', 0, 0)
        return res

LeetCode129. 求根节点到叶节点数字之和

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。

每条从根节点到叶节点的路径都代表一个数字：

例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。

计算从根节点到叶节点生成的所有数字之和。

叶节点是指没有子节点的节点。

示例 1：
在这里插入图片描述

输入：root = [1,2,3]
输出：25

解释：

从根到叶子节点路径 1->2 代表数字 12
从根到叶子节点路径 1->3 代表数字 13
因此，数字总和 = 12 + 13 = 25

示例 2：
在这里插入图片描述

输入：root = [4,9,0,5,1]
输出：1026

解释：

从根到叶子节点路径 4->9->5 代表数字 495
从根到叶子节点路径 4->9->1 代表数字 491
从根到叶子节点路径 4->0 代表数字 40

因此，数字总和 = 495 + 491 + 40 = 1026
思路1：
深度优先遍历，同时进行路径的字符串拼接。到达叶子节点（node.left is None and node.right is None）后，将该条路径的字符串存入列表val_list中。DFS完成后将得到一个列表val_list，存储所有根到叶子节点的字符串拼接值。接着将字符串转化为数字，求和即可。

class Solution:
    def sumNumbers(self, root: TreeNode) -> int:
        val_list = []

        def dfs(node:TreeNode, cur_val):
            if node:
                cur_val += str(node.val)
                if node.left is None and node.right is None:
                    val_list.append(cur_val)
                    return
                dfs(node.left, cur_val)
                dfs(node.right, cur_val)
        
        dfs(root, '')
        return sum([int(val) for val in val_list])

思路2：
进过思考可以发现，思路1中的拼接字符串可以优化为数值计算。即每次递归时，将上一层的值*10即可。

class Solution:
    def sumNumbers(self, root: TreeNode) -> int:
        val_list = []

        def dfs(node:TreeNode, cur_val):
            if node:
                cur_val = cur_val * 10 + node.val
                if node.left is None and node.right is None:
                    val_list.append(cur_val)
                    return
                dfs(node.left, cur_val)
                dfs(node.right, cur_val)
        
        dfs(root, 0)
        return sum(val_list)

思路3：
进一步发现，不需要将路径全存入val_list中，在DFS过程中即可以完成求和。即构造递归函数dfs(node:TreeNode, cur_val)的返回值，为以node为根节点的子树的路径之和。层层递归后根节点进行汇总dfs(root, 0)，即为最终结果。

class Solution:
	    def sumNumbers(self, root: TreeNode) -> int:
	        def dfs(node:TreeNode, cur_val):
	            if node:
	                cur_val = cur_val * 10 + node.val
	                if node.left is None and node.right is None:
	                    return cur_val
	                return dfs(node.left, cur_val) + dfs(node.right, cur_val)
	            return 0
	                
	        return dfs(root, 0)