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

标签：arr return 递归递归函数 Python print 15 def row

在这里插入图片描述

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

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

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

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')

这个例子展示了如何通过递归解决复杂问题，同时也体现了递归的分治策略。

使用技巧：

在面对问题时，思考是否可以通过分解为子问题来解决，这是递归的一个良好起点。
在设计递归函数时，始终定义清晰的基线情况和递归情况。

递归是编程中一个强大的概念，但使用得当才能发挥其真正的潜力。希望这篇文章能帮助你更好地掌握和应用递归技术！

关于python技术储备

由于文章篇幅有限，文档资料内容较多，需要这些文档的朋友，可以加小助手微信免费获取，【保证100%免费】，中国人不骗中国人。
在这里插入图片描述

                                     **（扫码立即免费领取）**

全套Python学习资料分享：

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，还有环境配置的教程，给大家节省了很多时间。

三、全套PDF电子书

书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。

四、入门学习视频全套

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

五、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。