🚀 Java 算法大全：从常用到冷门，一网打尽！ 🌟

涵盖 35+ 种算法，附带代码实现、流程图解、适用场景对比！
Emoji 标记快速定位，代码高亮 + 详细注释，助你快速掌握！

📊 排序算法

🔥 常用排序

1. 快速排序 (Quick Sort) | 🕒 O(n log n) | 🧠 分治思想

public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pivot = partition(arr, low, high); // 🎯 找基准点
        quickSort(arr, low, pivot - 1);         // ⚡ 递归左半
        quickSort(arr, pivot + 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;
}

适用场景: 大数据量、内存敏感、无需稳定性的排序（如日志排序）

2. 归并排序 (Merge Sort) | 🕒 O(n log n) | 🧠 分治 + 合并

public static void mergeSort(int[] arr, int left, int right) {
    if (left < right) {
        int mid = (left + right) / 2;
        mergeSort(arr, left, mid);    // 🌲 分割左半
        mergeSort(arr, mid + 1, right);// 🌲 分割右半
        merge(arr, left, mid, right); // 🧩 合并有序数组
    }
}

private static void merge(int[] arr, int left, int mid, int right) {
    int[] temp = new int[right - left + 1];
    int i = left, j = mid + 1, k = 0;
    while (i <= mid && j <= right) {  // 双指针合并
        temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
    }
    // 处理剩余元素
    while (i <= mid) temp[k++] = arr[i++];
    while (j <= right) temp[k++] = arr[j++];
    System.arraycopy(temp, 0, arr, left, temp.length); // 📤 拷贝回原数组
}

适用场景: 稳定排序、链表排序、外部排序（如大文件排序）

❄️ 冷门但有用的排序

1. 基数排序 (Radix Sort) | 🕒 O(nk) | 🧠 按位分配

public static void radixSort(int[] arr) {
    int max = Arrays.stream(arr).max().getAsInt();
    for (int exp = 1; max / exp > 0; exp *= 10) { // 按个位、十位...排序
        countSort(arr, exp);
    }
}

private static void countSort(int[] arr, int exp) {
    int[] output = new int[arr.length];
    int[] count = new int[10];
    // 统计各数字出现次数
    for (int num : arr) count[(num / exp) % 10]++;
    // 计算累计位置
    for (int i = 1; i < 10; i++) count[i] += count[i - 1];
    // 反向填充保证稳定性
    for (int i = arr.length - 1; i >= 0; i--) {
        output[count[(arr[i]/exp)%10] - 1] = arr[i];
        count[(arr[i]/exp)%10]--;
    }
    System.arraycopy(output, 0, arr, 0, arr.length);
}

适用场景: 整数排序、位数固定数据（如手机号排序）

🔍 搜索算法

🔥 常用搜索

1. 二分查找 (Binary Search) | 🕒 O(log n) | 🧠 折半查找

public static int binarySearch(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2; // 防溢出
        if (arr[mid] == target) return mid;   // 🎯 命中
        else if (arr[mid] < target) left = mid + 1; // ➡️ 右半区
        else right = mid - 1;                // ⬅️ 左半区
    }
    return -1;
}

适用场景: 有序数组查找（如字典查询）

❄️ 冷门搜索

1. 插值查找 (Interpolation Search) | 🕒 O(log log n) | 🧠 自适应猜测

public static int interpolationSearch(int[] arr, int target) {
    int low = 0, high = arr.length - 1;
    while (low <= high && target >= arr[low] && target <= arr[high]) {
        int pos = low + (target - arr[low]) * (high - low) / (arr[high] - arr[low]); // 🌈 动态计算位置
        if (arr[pos] == target) return pos;
        else if (arr[pos] < target) low = pos + 1;
        else high = pos - 1;
    }
    return -1;
}

适用场景: 均匀分布的数值查找（如温度传感器数据）

🧮 数学与加密算法

1. 欧几里得算法 (GCD) | 🕒 O(log min(a,b))

public static int gcd(int a, int b) {
    while (b != 0) {          // 🔄 辗转相除
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

适用场景: 求最大公约数、分数简化

2. RSA 加密算法 | 🧠 非对称加密

// 生成密钥对（简化示例）
public static KeyPair generateKeyPair() throws Exception {
    KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
    generator.initialize(2048); // 🔐 2048位密钥
    return generator.generateKeyPair();
}

适用场景: 安全通信、数字签名

🌐 图算法

1. Dijkstra 算法 | 🕒 O(V^2) | 🧠 单源最短路径

public void dijkstra(int[][] graph, int src) {
    int V = graph.length;
    int[] dist = new int[V];
    boolean[] visited = new boolean[V];
    Arrays.fill(dist, Integer.MAX_VALUE);
    dist[src] = 0;

    for (int count = 0; count < V-1; count++) {
        int u = minDistance(dist, visited); // 🎯 选最小距离节点
        visited[u] = true;
        for (int v = 0; v < V; v++) {      // 🔄 更新邻接节点
            if (!visited[v] && graph[u][v] != 0 && 
                dist[u] != Integer.MAX_VALUE && 
                dist[u] + graph[u][v] < dist[v]) {
                dist[v] = dist[u] + graph[u][v];
            }
        }
    }
}