常用算法详解

1. 引言

在计算机科学中，算法是解决问题的核心工具。掌握常用算法不仅可以提高编程效率，还能帮助开发者在面对复杂问题时找到合适的解决方案。本文将详细介绍几种常用的算法，涵盖排序算法、搜索算法、动态规划、贪心算法和图算法等。

2. 排序算法

排序算法是最基础的算法之一，用于将一组数据按照特定顺序排列。

2.1 冒泡排序

冒泡排序通过多次比较和交换相邻元素，将数据从小到大（或从大到小）逐步排序。

代码示例（Python）

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]
print(bubble_sort(arr))

2.2 快速排序

快速排序是一种分治算法，通过选择一个基准元素，将数组分成两部分，一部分小于基准元素，另一部分大于基准元素，递归地对两部分进行排序。

代码示例（Python）

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]
print(quick_sort(arr))

3. 搜索算法

搜索算法用于在数据集中查找特定元素。

3.1 线性搜索

线性搜索逐一检查数组中的每个元素，直到找到目标元素或遍历完整个数组。

代码示例（Python）

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1

arr = [64, 34, 25, 12, 22, 11, 90]
target = 25
print(linear_search(arr, target))

3.2 二分搜索

二分搜索适用于已排序的数组，通过反复将搜索范围减半，快速找到目标元素。

代码示例（Python）

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

arr = [11, 12, 22, 25, 34, 64, 90]
target = 25
print(binary_search(arr, target))

4. 动态规划

动态规划是一种通过将问题分解成子问题，并存储子问题的解来避免重复计算的算法。

4.1 斐波那契数列

计算斐波那契数列的第 n 个数。

代码示例（Python）

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

n = 10
print(fibonacci(n))

4.2 背包问题

在给定重量限制的情况下，选择物品使得总价值最大。

代码示例（Python）

def knapsack(weights, values, capacity):
    n = len(weights)
    dp = [[0] * (capacity + 1) for _ in range(n + 1)]
    for i in range(1, n + 1):
        for w in range(1, capacity + 1):
            if weights[i - 1] <= w:
                dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - weights[i - 1]] + values[i - 1])
            else:
                dp[i][w] = dp[i - 1][w]
    return dp[n][capacity]

weights = [1, 2, 3, 4]
values = [10, 20, 30, 40]
capacity = 5
print(knapsack(weights, values, capacity))

5. 贪心算法

贪心算法通过每一步选择当前最优解来求解问题。

5.1 零钱找零问题

在给定硬币面值和总金额的情况下，找到最少数量的硬币。

代码示例（Python）

def coin_change(coins, amount):
    coins.sort(reverse=True)
    count = 0
    for coin in coins:
        if amount >= coin:
            count += amount // coin
            amount %= coin
    return count if amount == 0 else -1

coins = [1, 2, 5, 10, 20, 50, 100]
amount = 93
print(coin_change(coins, amount))

5.2 活动选择问题

选择尽可能多的互不重叠的活动。

代码示例（Python）

def activity_selection(activities):
    activities.sort(key=lambda x: x[1])
    selected = []
    last_end_time = 0
    for activity in activities:
        if activity[0] >= last_end_time:
            selected.append(activity)
            last_end_time = activity[1]
    return selected

activities = [(1, 3), (2, 4), (3, 5), (0, 6), (5, 7), (8, 9)]
print(activity_selection(activities))

6. 图算法

图算法用于解决图结构中的问题，如最短路径、最小生成树等。

6.1 Dijkstra 算法

计算图中某一顶点到其他顶点的最短路径。

代码示例（Python）

import heapq

def dijkstra(graph, start):
    pq = [(0, start)]
    distances = {vertex: float('infinity') for vertex in graph}
    distances[start] = 0
    while pq:
        current_distance, current_vertex = heapq.heappop(pq)
        if current_distance > distances[current_vertex]:
            continue
        for neighbor, weight in graph[current_vertex].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(pq, (distance, neighbor))
    return distances

graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'C': 2, 'D': 5},
    'C': {'A': 4, 'B': 2, 'D': 1},
    'D': {'B': 5, 'C': 1}
}
start_vertex = 'A'
print(dijkstra(graph, start_vertex))

6.2 Prim 算法

构造图的最小生成树。

代码示例（Python）

import heapq

def prim(graph, start):
    mst = []
    visited = set()
    min_heap = [(0, start, None)]
    while min_heap:
        weight, current_vertex, previous_vertex = heapq.heappop(min_heap)
        if current_vertex not in visited:
            visited.add(current_vertex)
            if previous_vertex is not None:
                mst.append((previous_vertex, current_vertex, weight))
            for neighbor, weight in graph[current_vertex].items():
                if neighbor not in visited:
                    heapq.heappush(min_heap, (weight, neighbor, current_vertex))
    return mst

graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'C': 2, 'D': 5},
    'C': {'A': 4, 'B': 2, 'D': 1},
    'D': {'B': 5, 'C': 1}
}
start_vertex = 'A'
print(prim(graph, start_vertex))

7. 结论

常用算法是计算机科学的基础，掌握这些算法可以大大提高编程效率