递归算法

递归算法

 

递归算法是一种通过调用自身来解决问题的算法。递归算法通常涉及到将一个问题划分为较小的子问题来解决，并在子问题中调用自身来完成。

递归算法的基本思想是，将一个大问题转化为一个或多个相同结构的小问题，直到问题变得足够小以便直接解决。然后将这些小问题的解组合成原始问题的解。在递归算法中，一个函数通过调用自身来解决一个问题，直到问题的规模变得足够小，以至于函数可以直接解决它，这个过程被称为递归。

递归算法可以用于各种不同的问题，如搜索、排序、树和图的遍历等等。递归算法的优点是，它可以使代码更简单和易于理解，并且可以处理复杂的问题，因为它可以将问题分解为更小的、易于处理的子问题。然而，递归算法也有一些缺点，如可能会占用大量的堆栈空间、效率较低等问题，需要根据实际情况进行权衡。

 

应用

递归算法可以用于各种不同的问题，如搜索、排序、树和图的遍历、分治法等等。以下是一些递归算法的应用示例：

1.阶乘计算

递归算法可以用于计算阶乘，如下所示：

 

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

 

2.斐波那契数列

递归算法可以用于计算斐波那契数列，如下所示：

def fibonacci(n):
    if n == 0 or n == 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

3.二叉树遍历

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def preorderTraversal(root: TreeNode) -> List[int]:
    if not root:
        return []
    else:
        return [root.val] + preorderTraversal(root.left) + preorderTraversal(root.right)

4.分治法

def maxSubArray(nums):
    def divide_conquer(nums, left, right):
        if left == right:
            return nums[left]
        mid = (left + right) // 2
        left_sum = divide_conquer(nums, left, mid)
        right_sum = divide_conquer(nums, mid+1, right)
        cross_sum = find_cross_sum(nums, left, right, mid)
        return max(left_sum, right_sum, cross_sum)
    def find_cross_sum(nums, left, right, mid):
        left_sum = float('-inf')
        curr_sum = 0
        for i in range(mid, left-1, -1):
            curr_sum += nums[i]
            left_sum = max(left_sum, curr_sum)
        right_sum = float('-inf')
        curr_sum = 0
        for i in range(mid+1, right+1):
            curr_sum += nums[i]
            right_sum = max(right_sum, curr_sum)
        return left_sum + right_sum
    return divide_conquer(nums, 0, len(nums)-1)

以上就是递归的基本应用

接下来会有几个力扣练习题来帮助大家练习

练习题1

力扣509 斐波那契数列

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给定 n ，请计算 F(n) 。

 

class Solution:
    def fib(self, n: int) -> int:
        if n < 2:
            return 0 if n==0 else 1
        m =self.fib(n - 1) +self.fib(n - 2)
        return m

练习题二

力扣的206反转链表：

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

 

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:
            return head
        p =self.reverseList(head.next)
        head.next.next=head
        head.next=None
        return p

 

 

练习题三

力扣的344：反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

 

示例 1：

输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """

        left = 0
        right = len(s) - 1
        while(left < right):
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1
        return s