经典算法（如排序、查找、动态规划等）

经典的算法可以解决很多类型的问题，下面主要学习一些常用的算法：

1.排序算法

1.1 冒泡排序

每次比较相邻的两个元素，如果顺序错误就交换，直到该过程没有需要交换的元素。
举例：对学生成绩列表进行排序，从最低分到最高分排序。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

# 测试冒泡排序
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort(arr)
print("Sorted array:", sorted_arr)

1.2 快速排序

选择一个基准元素，将数组分成小于基准和大于基准元素的两部分，递归排序。
举例：对电商平台的商品价格进行排序，以便用户按价格筛选商品。

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

# 测试快速排序
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = quick_sort(arr)
print("Sorted array:", sorted_arr)

2.搜索算法

二分查找：
在有序数组中，每次比较中间元素，根据比较结果决定继续查找的半边。
举例：在电话簿中查找某个人的电话号码。

def binary_search(arr, x):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = left + (right - left) // 2
        if arr[mid] == x:
            return mid
        elif arr[mid] < x:
            left = mid + 1
        else:
            right = mid - 1
    return -1

# 测试二分查找
arr = [11, 22, 25, 34, 64, 90]
x = 25
result = binary_search(arr, x)
print("Element found at index:", result)

3.动态规划

3.1 斐波那契数列

使用递归关系 $F(n)=F(n-1)+F(n-2)$ 并保存已经计算过的结果，避免重复计算。
举例：计算第n个斐波那契数。

def fibonacci(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    dp = [0] * (n + 1)
    dp[1] = 1
    for i in range(2, n + 1):
        dp[i] = dp[i-1] + dp[i-2]
    return dp[n]

# 测试斐波那契数列
n = 5
print("Fibonacci number:", fibonacci(n))

3.2 背包问题

在给定重量限制的情况下，选择物品使得总价值最大化。
举例：在有限预算下，选择投资组合使得总收益最大。

def knapsack(W, wt, val, n):
    dp = [[0 for x in range(W + 1)] for x in range(n + 1)]
    for i in range(n + 1):
        for w in range(W + 1):
            if i == 0 or w == 0:
                dp[i][w] = 0
            elif wt[i-1] <= w:
                dp[i][w] = max(val[i-1] + dp[i-1][w-wt[i-1]], dp[i-1][w])
            else:
                dp[i][w] = dp[i-1][w]
    return dp[n][W]

# 测试背包问题
val = [60, 100, 120]
wt = [10, 20, 30]
W = 50
n = len(val)
print("Maximum value in Knapsack:", knapsack(W, wt, val, n))

4.贪心算法

活动选择问题

每次选择结束时间最早的活动，确保能安排更多的活动。
举例：在一天内安排尽可能多的会议。

def activity_selection(start, end):
    n = len(start)
    selected_activities = [0]
    last_end_time = end[0]
    for i in range(1, n):
        if start[i] >= last_end_time:
            selected_activities.append(i)
            last_end_time = end[i]
    return selected_activities

# 测试活动选择问题
start = [1, 3, 0, 5, 8, 5]
end = [2, 4, 6, 7, 9, 9]
selected = activity_selection(start, end)
print("Selected activities:", selected)