算法 - 算法优化

最新推荐文章于 2025-05-30 13:04:00 发布

原创最新推荐文章于 2025-05-30 13:04:00 发布 · 780 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#算法

数据结构及算法专栏收录该内容

6 篇文章

订阅专栏

算法优化

一、什么是算法优化？

定义

算法优化 是指通过改进算法的设计或实现，使其在时间复杂度、空间复杂度或其他性能指标上更加高效。
目标是减少计算资源（如时间、内存）的消耗，同时保持算法的正确性。

常见优化方向

时间优化：

减少算法的时间复杂度。
避免重复计算。

空间优化：

减少额外存储空间的使用。
使用原地算法（In-place Algorithm）。

代码优化：

简化逻辑，提升可读性和执行效率。

并行化与分布式处理：

利用多线程、多核处理器或分布式系统加速计算。

二、常见优化策略

2.1 时间优化

(1) 减少嵌套循环

问题：嵌套循环通常会导致时间复杂度呈指数增长。
优化：尝试将嵌套循环转化为单层循环，或使用更高效的算法。

示例：两数之和

// 暴力解法：O(n^2)
public static int[] twoSumBruteForce(int[] nums, int target) {
    for (int i = 0; i < nums.length; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[i] + nums[j] == target) {
                return new int[]{i, j};
            }
        }
    }
    return null;
}

// 优化：使用哈希表 O(n)
public static int[] twoSumOptimized(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement)) {
            return new int[]{map.get(complement), i};
        }
        map.put(nums[i], i);
    }
    return null;
}

(2) 分治法

思想：将大问题分解为小问题，分别解决后再合并结果。
优化：通过递归和分治降低时间复杂度。

示例：快速排序

public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pivotIndex = partition(arr, low, high);
        quickSort(arr, low, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, high);
    }
}

private static int partition(int[] arr, int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, high);
    return i + 1;
}

private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

(3) 动态规划

思想：通过保存子问题的解避免重复计算。
优化：将递归转化为迭代，利用记忆化技术。

示例：斐波那契数列

// 暴力递归：O(2^n)
public static int fibonacciRecursive(int n) {
    if (n <= 1) return n;
    return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2);
}

// 动态规划：O(n)
public static int fibonacciDP(int n) {
    if (n <= 1) return n;
    int[] dp = new int[n + 1];
    dp[0] = 0;
    dp[1] = 1;
    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[n];
}

2.2 空间优化

(1) 原地算法

思想：直接在输入数据上操作，无需额外存储空间。
优化：减少内存分配。

示例：反转数组

// 额外空间：O(n)
public static void reverseArrayExtraSpace(int[] arr) {
    int[] temp = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        temp[i] = arr[arr.length - 1 - i];
    }
    System.arraycopy(temp, 0, arr, 0, arr.length);
}

// 原地算法：O(1)
public static void reverseArrayInPlace(int[] arr) {
    int left = 0, right = arr.length - 1;
    while (left < right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
}

(2) 状态压缩

思想：用位运算代替数组存储状态。
优化：大幅减少内存占用。

示例：旅行商问题（TSP）

// 使用二维数组存储状态：O(n^2)
// 使用位掩码存储状态：O(2^n * n)
public static int tspBitmask(int[][] dist) {
    int n = dist.length;
    int[][] dp = new int[1 << n][n];
    for (int[] row : dp) Arrays.fill(row, Integer.MAX_VALUE);
    dp[1][0] = 0;

    for (int mask = 1; mask < (1 << n); mask++) {
        for (int u = 0; u < n; u++) {
            if ((mask & (1 << u)) == 0) continue;
            for (int v = 0; v < n; v++) {
                if ((mask & (1 << v)) != 0) continue;
                dp[mask | (1 << v)][v] = Math.min(dp[mask | (1 << v)][v], dp[mask][u] + dist[u][v]);
            }
        }
    }

    int res = Integer.MAX_VALUE;
    for (int u = 1; u < n; u++) {
        res = Math.min(res, dp[(1 << n) - 1][u] + dist[u][0]);
    }
    return res;
}

2.3 并行化与分布式处理

(1) 多线程

思想：将任务拆分为多个子任务，由多个线程并行处理。
优化：充分利用多核 CPU 提升性能。

示例：并行矩阵乘法

import java.util.concurrent.*;

public class ParallelMatrixMultiplication {
    public static void multiplyParallel(int[][] A, int[][] B, int[][] C, int numThreads) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(numThreads);
        int rowsA = A.length, colsB = B[0].length;

        for (int i = 0; i < rowsA; i++) {
            final int row = i;
            executor.submit(() -> {
                for (int j = 0; j < colsB; j++) {
                    C[row][j] = 0;
                    for (int k = 0; k < B.length; k++) {
                        C[row][j] += A[row][k] * B[k][j];
                    }
                }
            });
        }
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.HOURS);
    }
}

三、实际应用案例

3.1 缓存优化

场景：频繁访问的数据存储在缓存中以减少计算开销。
示例：LRU 缓存（最近最少使用）。

import java.util.LinkedHashMap;
import java.util.Map;

class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private int capacity;

    public LRUCache(int capacity) {
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > capacity;
    }
}

3.2 数据结构选择

场景：根据需求选择合适的数据结构。
示例：优先队列用于 Dijkstra 算法。

import java.util.PriorityQueue;

public class Dijkstra {
    public static void dijkstra(int[][] graph, int source) {
        int n = graph.length;
        int[] dist = new int[n];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[source] = 0;

        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
        pq.offer(new int[]{source, 0});

        while (!pq.isEmpty()) {
            int[] curr = pq.poll();
            int u = curr[0], d = curr[1];
            if (d > dist[u]) continue;

            for (int v = 0; v < n; v++) {
                if (graph[u][v] > 0 && dist[v] > dist[u] + graph[u][v]) {
                    dist[v] = dist[u] + graph[u][v];
                    pq.offer(new int[]{v, dist[v]});
                }
            }
        }

        System.out.println(Arrays.toString(dist));
    }
}