递归基础训练-路径总和

已于 2024-09-18 19:17:52 修改
阅读量824 收藏 10
点赞数 7
文章标签： python 开发语言
于 2024-09-17 23:45:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/he_wen_jie/article/details/142307098
版权

路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

我们可以把之前的值不断传递下去，然后到叶子节点判断是否满足条件，我们想要把之前的值一路传递下去，可以确定就是先序遍历，先对值进行处理然后传递下去，下一层可以拿到之前的所有值，然后再进行处理。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        self.ans = []

        def pathSum(root, path):
            if root is None:
                return
            print(root.val)
            if root.left is None and root.right is None:
                self.ans.append(sum(path)+root.val)
                return
            pathSum(root.left, path+[root.val])
            pathSum(root.right, path+[root.val])
        pathSum(root, [])
        print(self.ans)
        for s in self.ans:
            if s == targetSum:
                return True
        return False

终止条件：

  • 叶子节点可以作为一个终止条件，当遍历到叶子节点的时候拿到了所有的路径值，也就可以返回了root.left is None and root.right is None
  • 但是还有一种情况是节点是None，例如一个节点的左节点是None，右节点不为None，那么递归遍历左节点的时候也要停止递归并且返回，因为并不是叶子节点，所以不把结果记录下来
  • 叶子节点也可以不作为终止条件，可以作为结果的判断条件，当为叶子节点的时候把结果记录下来，继续递归

二叉树的停止条件主要就是叶子节点和None两种情况

可以引入一个外部变量来存储中间的计算结果

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        self.ans = False
        def pathSum(root, path):
            if root is None:
                return
            if root.left is None and root.right is None:
                if sum(path) + root.val == targetSum:
                    self.ans = True
                return

            pathSum(root.left, path+[root.val])
            pathSum(root.right, path+[root.val])
        pathSum(root,[])


        return self.ans

在这里插入图片描述

直接根据子问题还原出原问题，子问题：

  • 左子树是否存在某条路径的和满足target-root.val
  • 右子树是否存在某条路径的和满足target-root.val

原问题：如果左子树存在或者右子树存在，那么就存在

终止条件：

  • 子节点：如果到了子节点，那么只需要判断子节点与targetSum是否相等即可，也可以认为当前就只有一个节点
  • 节点为None，如果节点为None的话，那肯定就是不满足情况，返回False
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if root is None:
            return False
        if root.left is None and root.right is None:
            return root.val == targetSum
        
        l = self.hasPathSum(root.left, targetSum-root.val)
        r = self.hasPathSum(root.right, targetSum-root.val)
        
        return l or r

路径总和 II

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

要把所有搜索路径存储下来，那么必然是把之前的节点都记录下来并且传递下去，这样后续的节点才可以拿到之前的节点

路径总和 III

给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。
路径 不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

对于不是必须经过根节点的问题，可以将每个节点看作是根节点来搜索原问题。
在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> int:
        self.ans = []
        # 求一个二叉树中存在路径和为targetSum的路径
        def everyNodePathSum(root, targetSum, path):
            if root is None:
                return
            
            if root.left is None and root.right is None:
                if root.val == targetSum:
                    self.ans.append(path + [root.val])
                return
            
            everyNodePathSum(root.left, targetSum - root.val, path + [root.val])
            everyNodePathSum(root.right, targetSum - root.val,path + [root.val])
        
        # 遍历一个二叉树，求每个节点下存在路径为targetSum的路径
        def dfs(root):
            if root is None:
                return
            everyNodePathSum(root,targetSum,[])
            dfs(root.left)
            dfs(root.right)
        
        dfs(root)
        print(self.ans)

终止条件发生了改变，不一定是到叶子节点才终止，只要在遍历的过程中存在和为targetSum的路径就存储下来

发现了一个问题，叶子节点并不是终止条件，只能说是一个判断条件，当到达叶子节点时候判断是否需要将路径加进来

[1,-1,[2,-2],[1,-1,2,-2]都是满足targetSum的路径，因此即使中间结果满足了targetSum也不能直接返回，还需要接着往下遍历
在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> int:
        self.ans = []
        def everyNodePathSum(root, targetSum, path):
            if root is None:
                return
            # 不需要再叶子节点判断，每个节点都可以判断
            # 并且删除return，因为一个路径可能存在多种解
            if root.val == targetSum:
                self.ans.append(path + [root.val])
            
            everyNodePathSum(root.left, targetSum - root.val, path + [root.val])
            everyNodePathSum(root.right, targetSum - root.val,path + [root.val])
        
        def dfs(root):
            if root is None:
                return
            everyNodePathSum(root,targetSum,[])
            dfs(root.left)
            dfs(root.right)
        
        dfs(root)
        print(self.ans)

做一个小修改来满足题解

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> int:
        self.ans = 0

        def everyNodePathSum(root, targetSum, path):
            if root is None:
                return
            
            if root.val == targetSum:
                self.ans += 1
            
            everyNodePathSum(root.left, targetSum - root.val, path + [root.val])
            everyNodePathSum(root.right, targetSum - root.val,path + [root.val])

        def dfs(root):
            if root is None:
                return
            everyNodePathSum(root,targetSum,[])
            dfs(root.left)
            dfs(root.right)
        
        dfs(root)
        return self.ans

二叉树的最大深度

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

根节点到叶子节点，我们同样可以把路径记录下来，当到达叶子节点的时候直接统计就可以

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        self.ans = []
        def getPath(root, path):
            if root is None:
                return
            
            if root.left is None and root.right is None:
                self.ans.append(path + [root.val])
            
            # 将当前节点添加到path中，并传递给左子树
            getPath(root.left, path + [root.val])
            # 将当前节点添加到path中，并传递给左子树
            getPath(root.right, path + [root.val])
        
        getPath(root, [])
        if len(self.ans) == 0:
            return 0
        return max(map(len, self.ans))

我们是求最大路径，其实并不需要将路径记录下来，只需要将路过的节点数记录下来就可以了
在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        self.ans = 0
        def getPath(root, depth):
            if root is None:
                return

            if root.left is None and root.right is None:
                self.ans = max(self.ans, depth+1)
            
            # 之前的个数+1就是当前的深度，然后传递下去，左子树就是知道之前路过了几个节点
            getPath(root.left, depth+1)
            # 之前的个数+1就是当前的深度，然后传递下去，右子树就是知道之前路过了几个节点
            getPath(root.right, depth+1)
        
        getPath(root, 0)
        return self.ans

这个问题也可以直接考虑子问题
子问题：左子树的最大深度和右子树的最大深度
还原原问题：max(左子树最大深度，右子树最大)+1就是当前节点的最大深度

通常考虑后序遍历，

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0
        
        l = self.maxDepth(root.left)
        r = self.maxDepth(root.right)

        return max(l,r)+1

二叉树的直径

二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。

最开始的想法是假如求出了左子树直径和右子树的直径，那么当前节点的直径就是左子树直径+右子树直径+1。但是会发现左子树的直径和右子树的直径并不能直接拼接成根节点的直径。
左子树的直径是[4,3,2,6]，右子树的直径是[8,7,9]，预期根节点的直径是[4,3,2,6]+[1]+[8,7,9]，而根节点的实际直径是[4,3,2]+[1]+[7,9]。也就是说子问题的解无法合并成原问题，我们这种划分就是不对的。
在这里插入图片描述
观察后发现，根节点的直径是左子树的深度+1+右子树的深度。不只是根节点，每个节点的直径都是左子树的深度+1+右子树的深度。也就是说我们只要遍历每个节点的左右子树深度就可以了

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
        self.ans = 0
        def depth(root):
            if root is None:
                return 0
            
            l = depth(root.left)
            r = depth(root.right)
            d = max(l,r) + 1
            self.ans = max(self.ans, l+r)
            return d
        depth(root)
        return self.ans

这样左子树的最大深度一定是左节点一直往下到叶子节点的一条路径/，右子树的最大深度也是右节点一直往下到一条路径\，（不会出现/\这样的路径），然后加上根节点就是直径了。

二叉树中的最大路径和

路径和 是路径中各节点值的总和

这个问题也很有意思，一个简单的想法就是求出左子树的最大路径和，求出右子树的最大路径和，那么根节点的最大路径和就是root.val + max(0,左子树的路径和) + max(0,右子树的路径和)，对左右子树取max的原因是路径和可以为负数，当为负数的时候就不要加在根节点上。

同样最大路径和不一定过根节点，也就是要遍历所有的节点，可以用全局变量存储最大值

ans = float('-inf')
def dfs(root):
	if root is None:
		return 0
	
	l = max(0, dfs(root.left))
	r = max(0, dfs(root.right))
	
	v = l + r + root.val
	ans = max(ans,v)
	return v

这种写法是有问题的
在这里插入图片描述
本质还是因为左右子树的最大和路径不一定能拼接到根节点，也就是说子问题无法还原出原问题。考虑过根节点的最大路径和，也就是从根节点一路向下得到的路径和，根节点的最大路径和就是 左边路径和右边路径求出哪个大，然后跟0比较，如果小于0那么就不要加到根路径中

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxPathSum(self, root: Optional[TreeNode]) -> int:
        self.ans = float('-inf')
        def dfs(root):
            if root is None:
                return 0
            
            l = max(dfs(root.left),0)
            r = max(dfs(root.right),0)
            # 过跟节点的最大路径和
            v = l + r + root.val
            self.ans = max(self.ans, v)
            # 返回的是根节点的最大路径
            return max(l,r) + root.val
        
        dfs(root)
        return self.ans

二叉树的直径和二叉树的最大路径本质都是在求路径，也就是要从根节点走到叶子节点，但是有两个比较难理解的地方

  1. 最终结果并不一定过根节点，任何一个节点都有可能是一个解，因此要遍历每个节点
  2. 简单的子问题无法还原出原问题的解，需要将问题转化一下，并且原始问题的解是在遍历的时候以中间结果记录下来的

总结

  1. 二叉树在递归的时候会遍历每一个节点，走完所有的路径，我们可以把之前遍历的节点信息放到path中传递下去，一直到叶子节点就拿到了所有的路径
def dfs(root, path):
	# 如果为None就直接返回，比如一个节点左孩子是None，右孩子非空
	# dfs(None), dfs(root.right)
	if root is None:
		return
	# 搜索路径就是根节点到叶子节点，直接打印路径
	if root.left is None and root.right is None:
		print(path)
		# 可以return也可以不return，因为根节点的左右子树都是None
		# 继续往下执行就是左子树dfs(None),右子树dfs(None)
		# return
	dfs(root.left, path + [root.val])
	dfs(root.right, path + [root.val])
  1. 每次在传递path的时候，其实发生了一次拷贝，递归左子树，会拷贝一份path传下去，递归右子树，同样拷贝一份path传递下去。左子树如何修改path都不会影响右子树的path

在这里插入图片描述
3. 二叉树明明只是遍历了一遍节点为什么可以得到所有的路径呢？一开始我的想法是先序遍历到叶子节点，停止后再回溯遍历右子树，然后再网上回溯。这种想法其实是不太完善。从递归树上可以知道，左右子树其实都执行了dfs，然后子树的子树也都执行了dfs，在递进的时候其实每个节点就已经都执行了处理
对于节点7和节点8，都拿到了之前的路径，

def dfs(5,[1,2]):
	dfs(7,[1,2,5])
	dfs(8,[1,2,5])

可以看到并不需要所谓的回溯，节点7拿到了之前所有的路径，并执行dfs记录了一条路径，而节点8也执行了dfs，拿到之前的路几个并记录了一条路径。也可以认为7和8是同时遍历的

def dfs(5,[1,2]):
	thread(dfs(7,[1,2,5])) 
	thread(dfs(8,[1,2,5]))

def dfs(root):
	if root is None:
		return
	before_process()
	dfs(root.left)
	dfs(root.right)
	after_process()

说明白了每个节点都会执行before_process和after_process，区别在于before_process是递归之前调用的，我们先对数据进行处理，然后再递归，处理完成的数据可以继续传递下去，例如path，而after_process是归的时候执行的，处理完成的结果逐步向上返回
先序遍历

max_depth = 0
def depth(root,d=0):
	# 节点为空就直接返回，无需继续执行
	if root is None:
		return
	# 当前节点不为None，路径长度+1
	d += 1 # 之前经历过了多少个节点
	max_depth = max(max_depth, d)
	depth(root.left, d)  # 处理好的数据传递下去
	depth(root.right, d) # 处理好的数据传递下去

后序遍历

def depth(root):
	# 节点为空就直接返回，无需继续执行
	if root is None:
		return 0
	l = depth(root.left)  # 处理好的数据传递下去
	r = depth(root.right) # 处理好的数据传递下去
	d = max(l,r) # 后序处理完成后向上返回
	return d

后序遍历就是把小的子问题逐步还原出原问题的结果。

二叉树直径：从某个节点到叶子节点的最长路径，其实就是最大深度

def depth(root):
	if root is None:
		return 0
	l = depth(root.left)
	r = depth(root.right)
	
	d = max(l,r)
	return d

最大深度还是比较好理解的，一路递归下去（到叶子节点）如果碰到None则返回0，在遍历的过程中其实会记录所有的路径，我们在这些路径中选择一条最长的也就是最大深度

def depth(root):
	if root is None:
		return 0
	l = depth(root.left)
	r = depth(root.right)
	
	d = max(l,r)
	return d

在这里插入图片描述

深度学习基础--模型拟合
wang6562009的专栏
08-30 1638
模型拟合 损失与网络参数有关，本章着重于探讨如何确定能使损失最小化的参数值。这个过程称为网络参数的学习，或更通俗地说，是模型的训练或拟合。该过程首先是选取一组初始参数值，随后重复执行两个步骤： (i) 计算损失函数关于参数的导数（梯度）； (ii) 根据梯度调整参数，以期减少损失。多次迭代后，目标是使损失函数达到其全局最小值。 本章重点讨论参数调整步骤，即采用何种算法来减少损失。 6.1 梯度下降 为了拟合模型，我们需要一组输入/输出对的训练集 {xi,yi}\{x_i, y_i\}{xi​,yi​}。
Python 基础 (-)
banghu8816的博客
09-28 2703
该笔记源自尚学堂,非原创 Python 单词是“大蟒蛇”的意思。但是龟叔不是喜欢蟒蛇才起这个名字，而是正在追剧：英国电视喜剧片《蒙提·派森的飞行马戏团》(Monty Python and the Flying Circus)。 使用 www.python.org 提供的 interactive shell 入门 Python · 特点 可读性强 可读性...
LC112-路径总和-递归
qq_38999897的博客
07-29 190
题目 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 例子： 给定如下二叉树，以及目标和 sum = 22 5 / \ 4 8 / / \ 11 13 4 / \ \ 7 2 1 返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5-&g
112 路径总和（递归）
二哈
04-19 280
1. 问题描述： 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 说明:叶子节点是指没有子节点的节点。 示例: 给定如下二叉树，以及目标和 sum = 22， 5 / \ 4 8 / / \ ...
递归专题训练详解（回溯，剪枝，深度优先）
m0_74234485的博客
09-23 883
在经典汉诺塔问题中，有 3 根柱子及 N 个不同大小的穿孔圆盘，盘子可以滑入任意一根柱子。一开始，所有盘子自上而下按升序依次套在第一根柱子上(即每一个盘子只能放在更大的盘子上面)。移动圆盘时受到以下限制:(1) 每次只能移动一个盘子;(2) 盘子只能从柱子顶端滑出移到下一根柱子;(3) 盘子只能叠在比它大的盘子上。
求解汉诺塔问题(提示, 使用递归)
helloword233的博客
09-19 6552
package com.test; import java.util.Scanner; public class Test { //主方法 public static void main(String[] args){ Scanner in = new Scanner(System.in); System.out.println("请输入汉诺塔的层数:"...
递归题目训练2(总结)
Clichong
06-08 555
一、扭蛋机 通过率100% 题目描述 22娘和33娘接到了小电视君的扭蛋任务： 一共有两台扭蛋机，编号分别为扭蛋机2号和扭蛋机3号，22娘使用扭蛋机2号，33娘使用扭蛋机3号。 扭蛋机都不需要投币，但有一项特殊能力： 扭蛋机2号：如果塞x（x范围为>=0正整数）个扭蛋进去，然后就可以扭到2x+1个 扭蛋机3号：如果塞x（x范围为>=0正整数）个扭蛋进去，然后就可以扭到2x+2个 22娘...
递归思维训练营：7大经典问题解锁递归解题策略
[递归思维训练营：7大经典问题解锁递归解题策略](https://img-blog.csdnimg.cn/94baa18b18544339a79d33e6d4277249.png) # 1. 递归思维的数学原理与哲学 ## 1.1 递归的定义与本质 递归是计算机科学和数学中的一种...
Java解决LeetCode第112题：路径总和题解
资源摘要信息:"java-leetcode题解之第112题路径总和.zip" 在深度解析这个压缩包资源之前，需要明确几个关键点。首先，该资源名为“java-leetcode题解之第112题路径总和.zip”，这表明它是一个针对编程练习平台...
递归vs迭代：Java实现最短路径算法的对比解析
最短路径问题的理论基础 最短路径问题（Shortest Path Problem, SPP）是图论中的一个经典问题，也是计算几何、网络优化和运筹学等领域中一个核心议题。这一问题的核心是在一个有权重的图中找到两个顶点之间的最短...
路径总和（1和2）
kirei12315的博客
02-23 74
做这道题之前首先提到一点，那就是递归什么时候需要返回值，什么时候不需要返回值，可以分为三类：要遍历整颗二叉树，同时不需要处理返回值，递归函数就不需要返回值（路径总和2）需要搜索整棵二叉树，同时还需要处理递归返回值，则递归函数就需要返回值（二叉树的最近公共祖先）只需要遍历部分二叉树，则递归一定需要返回值，因为遇到了符合条件的就要及时返回（路径总和1）
【LeetCode】递归精选8题——基础递归、链表递归
Qiuhan_909的博客
02-20 3464
LeetCode 递归精选8题（包含基础递归、链表递归） 详解
【C语言入门】递归问题及相应练习
最新发布
qq_25850439的博客
02-19 2143
带你由浅入深了解递归，以及包括常见的递归题的解法。题目：1.阶乘 2.字符串的长度 3.逆序字符串 4.打印数字的每一位 5. 每一位数字求和 6.斐波那契数列 7.青蛙跳台阶 8.汉诺塔问题。
递归算法(练习习题)
qq_45567031的博客
08-16 2330
递归：自己调用自己 递归模板： def recursion(level, param1, param2, ....): #第一部分：递归终止条件 if level > MAX_LEVEL: process_result return #该层所需执行的操作 process(...) #下探到下一层 self.recursuion(level+1, p1,...) #其他操作 总结： 第一部分：递归终止条件。 第二部分：该层所需解决的程序。 第三部分：下探到下一层。 例题： 题目
递归算法练习
FKDXM的博客
04-23 361
1、依次输出数组中的元素 void Print_Ar(int* br, int n) { assert(br != nullptr); if (n > 0) { Print_Ar(br, n - 1); printf("%d ", br[n - 1]); } } int main() { const int n = 5; int ar[n] = { 12,23,34,45,56 }; Print_Ar(ar, n); return 0; } 如果想正序输出元素，就先递归再输
【JavaSE系列】递归经典练习题
哎呀是小张啊 的博客
03-21 3686
递归的经典习题
递归习题练习，从了解到精通
chuxinchangcun的博客
07-25 6571
前言： 目录 前言： 什么是递归？ 递归的好处是什么？ 递归使用时有条件吗？ 什么时候使用递归？ 习题练习： 1.用递归的方式顺序打印一个数的每一位 2.用递归的方式逆序打印一个数 3.用非递归的方式求阶乘 4.用递归的方式求阶乘 5.用非递归的方式模拟实现strlen函数 6.用递归的方式模拟实现strlen函数 7.用非递归实现字符串逆序 8.用递归实现字符串逆序 9.用递归计算一个数拆分成每一位之后的每位之和 10.用递归实现计算n的k次方 11.用非递归...
递归练习
weixin_43615992的博客
05-27 221
递归三要素： 1、确定递归函数的参数和返回值 2、确定终止条件 3、确定单层递归的逻辑 第一题：斐波那切数列 class Solution { public: int Fibonacci(int n) { int a1=0,a2=1; return res(a1,a2,n); } int res(int a1, int a2, int num){ if(num == 0) return a1; if(num ==
递归地推练习总结
Trust_Youself
04-18 1010
递归：程序直接或间接调用自身的编程技巧称为递归算法，直接或间接调用自身的函数称为递归函数，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。 递归的基本思想：把一个不能或不好解决的大问题转化为一个或几个小问题，再把这些小问题进一步分解成更小的小问题，最小问题可以直接解决。递归的关键在于找出递归定义和递归的终止条件。 递归算法解题一般分为三个步骤： 1）分析问题、寻找
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值