def fibonacci_memo(n, memo={}):
if n in memo:
return memo[n] #缓存放在这个字典（数组）里面，当下次有同样的n，不用计算了
if n == 0:
return 0
elif n == 1:
return 1
else:
result = fibonacci_memo(n-1, memo) + fibonacci_memo(n-2, memo)
memo[n] = result
return result
# 测试优化后的函数
print(fibonacci_memo(5)) # 输出 5
在这个版本中，我们引入了一个 memo 字典，它会缓存已经计算过的 fibonacci(n) 值。这样，当我们再次遇到相同的 n 时，就可以直接返回缓存的结果，避免重复计算。
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid]) # 递归分割左半部分
right = merge_sort(arr[mid:]) # 递归分割右半部分
return merge(left, right)
def merge(left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result
# 测试
arr = [38, 27, 43, 3, 9, 82, 10]
print(merge_sort(arr)) # 输出：[3, 9, 10, 27, 38, 43, 82]
这段代码实现了 归并排序（Merge Sort）算法，它是一种分治法（Divide and Conquer）排序算法。归并排序的基本思想是：将数组分成两个子数组，递归地对它们进行排序，然后将两个已排序的子数组合并成一个有序数组。具体的代码解释如下：
1. merge_sort 函数：
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid]) # 递归分割左半部分
right = merge_sort(arr[mid:]) # 递归分割右半部分
return merge(left, right)
功能：实现归并排序的递归过程。
过程 ：
基准条件：当数组长度小于等于 1 时，直接返回数组（因为一个元素的数组已经是有序的）。
分割 ：将数组 arr 从中间分割成两个子数组：left 和 right。
递归排序 ：分别对 left 和 right 进行递归排序，直到数组分割到足够小（每个子数组只有一个元素）。
合并 ：通过调用 merge 函数将排序好的 left 和 right 合并为一个有序数组并返回。
2. merge 函数：
def merge(left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result
功能 ：合并两个已排序的子数组 left 和 right 成一个有序数组。
过程 ：
使用两个指针 i 和 j 分别指向 left 和 right 数组的开头。
比较 left[i] 和 right[j]，将较小的元素加入到结果数组 result 中，并相应地移动指针 i 或 j。
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[0] # 选择第一个元素为基准
less = [x for x in arr[1:] if x <= pivot] # 小于基准的部分
greater = [x for x in arr[1:] if x > pivot] # 大于基准的部分
return quick_sort(less) + [pivot] + quick_sort(greater)
# 测试
arr = [38, 27, 43, 3, 9, 82, 10]
print(quick_sort(arr)) # 输出：[3, 9, 10, 27, 38, 43, 82]
这段代码实现了 快速排序（Quick Sort）算法，它是一种分治法（Divide and Conquer）排序算法。快速排序的基本思想是通过选择一个"基准"元素，将数组分为小于基准的部分和大于基准的部分，然后递归地对这两个部分进行排序。
1. quick_sort 函数：
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[0] # 选择第一个元素为基准
less = [x for x in arr[1:] if x <= pivot] # 小于基准的部分
greater = [x for x in arr[1:] if x > pivot] # 大于基准的部分
return quick_sort(less) + [pivot] + quick_sort(greater)
def hanoi(n, source, target, auxiliary):
if n == 1:
print(f"Move disk 1 from {source} to {target}")
else:
hanoi(n-1, source, auxiliary, target) # 将n-1个盘子从源柱子移到辅助柱子
print(f"Move disk {n} from {source} to {target}")
hanoi(n-1, auxiliary, target, source) # 将n-1个盘子从辅助柱子移到目标柱子
# 测试
hanoi(3, 'A', 'C', 'B')
这段代码实现了经典的 汉诺塔问题（Tower of Hanoi）的递归解法。
上面的汉诺塔问题可以仔细分析如下：
有三根柱子（源柱子 A、目标柱子 C、辅助柱子 B），和若干个盘子（每个盘子的大小不同）。
任务是将所有盘子从源柱子移动到目标柱子，且遵守以下规则：
每次只能移动一个盘子。
任何时候大盘子不能放在小盘子上面。
使用辅助柱子来帮助移动。
代码分析：
hanoi 函数：
def hanoi(n, source, target, auxiliary):
if n == 1:
print(f"Move disk 1 from {source} to {target}")
else:
hanoi(n-1, source, auxiliary, target) # 将n-1个盘子从源柱子移到辅助柱子
print(f"Move disk {n} from {source} to {target}")
hanoi(n-1, auxiliary, target, source) # 将n-1个盘子从辅助柱子移到目标柱子
同样，先将盘子 1 从 B 移动到 A，再将盘子 2 从 B 移动到 C，最后将盘子 1 从 A 移动到 C。
输出：
Move disk 1 from A to C
Move disk 2 from A to B
Move disk 1 from C to B
Move disk 3 from A to C
Move disk 1 from B to A
Move disk 2 from B to C
Move disk 1 from A to C
