Python中15个递归函数经典案例解析

news2024/11/15 2:12:23

文末赠免费精品编程资料~~

递归是Python编程中一个强大的工具，它允许函数调用自身以解决复杂问题。在本文中，我们将探索15个递归函数的经典案例，从基础到进阶，帮助你理解和掌握递归编程。

1. 阶乘计算

阶乘是一个常见的递归应用，定义为n! = n * (n-1) * … * 1。

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

print(factorial(5))  # 输出: 120

2. 斐波那契数列

斐波那契数列的每一项都是前两项的和。

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

print(fibonacci(10))  # 输出: 55

3. 汉诺塔问题

汉诺塔是一个经典的递归问题，涉及将多个盘子从一个柱子移动到另一个柱子。

def hanoi(n, source, target, auxiliary):
    if n > 0:
        hanoi(n - 1, source, auxiliary, target)
        print(f"Move disk {n} from {source} to {target}")
        hanoi(n - 1, auxiliary, target, source)

hanoi(3, 'A', 'C', 'B')

4. 幂运算

计算a的n次方。

def power(a, n):
    if n == 0:
        return 1
    elif n % 2 == 0:
        return power(a * a, n // 2)
    else:
        return a * power(a, n - 1)

print(power(2, 10))  # 输出: 1024

5. 数组求和

递归地计算数组元素的总和。

def array_sum(arr):
    if not arr:
        return 0
    else:
        return arr[0] + array_sum(arr[1:])

print(array_sum([1, 2, 3, 4]))  # 输出: 10

6. 字符串反转

使用递归来反转字符串。

def reverse_string(s):
    if len(s) <= 1:
        return s
    else:
        return reverse_string(s[1:]) + s[0]

print(reverse_string("hello"))  # 输出: "olleh"

7. 找出数组中的最大值

递归地找出数组中的最大值。

def find_max(arr):
    if len(arr) == 1:
        return arr[0]
    else:
        sub_max = find_max(arr[1:])
        return arr[0] if arr[0] > sub_max else sub_max

print(find_max([3, 1, 4, 1, 5, 9]))  # 输出: 9

8. 二叉树遍历

递归地遍历二叉树。

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

def inorder_traversal(node):
    if node is not None:
        inorder_traversal(node.left)
        print(node.val, end=" ")
        inorder_traversal(node.right)

root = Node(1, Node(2), Node(3))
inorder_traversal(root)  # 输出: 2 1 3

9. 平衡括号检查

检查字符串中的括号是否平衡。

def balanced_parentheses(s):
    if not s:
        return True
    if s[0] == '(' and s[-1] == ')':
        return balanced_parentheses(s[1:-1])
    else:
        return False

print(balanced_parentheses("(())"))  # 输出: True

10. 帕斯卡三角形

生成帕斯卡三角形。

def pascals_triangle(n):
    if n == 1:
        return [1]
    else:
        row = [1]
        prev_row = pascals_triangle(n - 1)
        for i in range(len(prev_row) - 1):
            row.append(prev_row[i] + prev_row[i + 1])
        row.append(1)
        return row

for i in range(1, 6):
    print(pascals_triangle(i))

11. 迷宫路径

寻找迷宫的解决方案。

def maze_path(x, y, m, n):
    if x == m or y == n:
        return []
    elif x == m - 1 and y == n - 1:
        return [(x, y)]
    else:
        paths1 = maze_path(x + 1, y, m, n)
        paths2 = maze_path(x, y + 1, m, n)
        for path in paths1 + paths2:
            path.insert(0, (x, y))
        return paths1 + paths2

m, n = 3, 3
paths = maze_path(0, 0, m, n)
for path in paths:
    print(path)

12. 字符串排列

生成字符串的所有可能排列。

def string_permutations(s):
    if len(s) == 1:
        return [s]
    else:
        permutations = []
        for i in range(len(s)):
            char = s[i]
            remaining_chars = s[:i] + s[i+1:]
            for permutation in string_permutations(remaining_chars):
                permutations.append(char + permutation)
        return permutations

print(string_permutations('abc'))

13. 八皇后问题

解决八皇后问题。

def solve_n_queens(n):
    solutions = []
    def place_queen(row, cols):
        if row == n:
            solutions.append(cols)
            return
        for col in range(n):
            if all(abs(c - col) not in (0, row - i) for i, c in enumerate(cols[:row])):
                place_queen(row + 1, cols + [col])
    place_queen(0, [])
    return solutions

for solution in solve_n_queens(8):
    print(solution)

14. 斗地主发牌

模拟斗地主游戏发牌过程。

import random

def deal_cards():
    cards = ['3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A', '2'] * 4 + ['小王', '大王']
    random.shuffle(cards)
    hands = {'player1': [], 'player2': [], 'player3': []}
    for i in range(17):
        for player in hands:
            hands[player].append(cards.pop())
    return hands

print(deal_cards())

15. 字符串匹配

检查一个字符串是否包含另一个字符串。

def string_match(s, pattern):
    if not pattern:
        return True
    if not s:
        return False
    if s[0] == pattern[0]:
        return string_match(s[1:], pattern[1:])
    else:
        return string_match(s[1:], pattern)

print(string_match("hello", "he"))  # 输出: True

高级技巧：

1. 尾递归优化

尾递归是一种特殊的递归形式，其中递归调用是函数执行的最后一个操作。某些语言（如Scheme）会自动优化尾递归，但在Python中，你需要手动转换递归为迭代或使用生成器和协程来避免栈溢出。

2. 记忆化

记忆化是一种优化技术，用于存储先前计算的结果，从而避免重复计算。这对于像斐波那契数列这样的问题特别有用，可以显著提高性能。

def memoize(f):
    cache = {}
    def helper(x):
        if x not in cache:            
            cache[x] = f(x)
        return cache[x]
    return helper

@memoize
def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

3. 递归与分治法

分治法是一种将问题分解成若干较小的相同或相似子问题的策略，直到这些子问题变得足够简单，可以直接求解。递归是实现分治法的一种自然方式。

实战案例分析：汉诺塔问题

汉诺塔问题是一个典型的递归案例，涉及到将多个圆盘从一个柱子移动到另一个柱子上，但每次只能移动一个圆盘，且大盘不能放在小盘之上。

def hanoi(n, source, target, auxiliary):
    if n > 0:
        # 将n-1个圆盘从source移动到auxiliary
        hanoi(n - 1, source, auxiliary, target)
        # 移动最大的圆盘从source到target
        print(f"Move disk {n} from {source} to {target}")
        # 将n-1个圆盘从auxiliary移动到target
        hanoi(n - 1, auxiliary, target, source)

# 示例调用
hanoi(3, 'A', 'C', 'B')