Java排序算法全解：从基础到高级实现指南

Java排序算法全解：从基础到高级实现指南

【免费下载链接】Java All Algorithms implemented in Java 项目地址: https://gitcode.com/GitHub_Trending/ja/Java

你是否在开发中为选择合适的排序算法而困惑？面对冒泡、快排、归并等十余种排序方法，如何根据数据规模和特性做出最优选择？本文将系统解析src/main/java/com/thealgorithms/sorts/目录下30+种Java排序实现，从时间复杂度到实战代码，助你一次掌握排序算法的核心原理与应用技巧。

基础排序算法：原理与实现

冒泡排序（Bubble Sort）

冒泡排序通过重复交换相邻元素实现排序，是最基础的排序算法之一。其核心逻辑在BubbleSort.java中实现：

public void sort(int[] array) {
    int n = array.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                SortUtils.swap(array, j, j + 1);
            }
        }
    }
}

该实现使用了项目提供的SortUtils.java工具类，封装了常用的交换操作。冒泡排序的时间复杂度为O(n²)，适用于小规模数据排序。

选择排序（Selection Sort）

选择排序通过每次选择最小元素放到已排序序列末尾实现。SelectionSort.java的核心代码如下：

public void sort(int[] array) {
    int n = array.length;
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (array[j] < array[minIndex]) {
                minIndex = j;
            }
        }
        SortUtils.swap(array, i, minIndex);
    }
}

选择排序同样具有O(n²)的时间复杂度，但交换操作仅需n-1次，优于冒泡排序。

高级排序算法：性能优化与应用

快速排序（Quick Sort）

快速排序采用分治策略，通过基准元素将数组分区。QuickSort.java实现了经典快速排序算法：

public void sort(int[] array, int low, int high) {
    if (low < high) {
        int pi = partition(array, low, high);
        sort(array, low, pi - 1);
        sort(array, pi + 1, high);
    }
}

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

快速排序平均时间复杂度为O(n log n)，是实际应用中的首选排序算法。项目中还提供了DualPivotQuickSort.java实现，通过双基准元素进一步优化性能。

归并排序（Merge Sort）

归并排序通过分治与合并操作实现稳定排序。MergeSort.java的递归实现如下：

public void sort(int[] array, int left, int right) {
    if (left < right) {
        int mid = (left + right) / 2;
        sort(array, left, mid);
        sort(array, mid + 1, right);
        merge(array, left, mid, right);
    }
}

private void merge(int[] array, int left, int mid, int right) {
    // 合并两个有序子数组
}

归并排序具有稳定的O(n log n)时间复杂度，但需要额外的O(n)空间。项目中还提供了MergeSortNoExtraSpace.java实现，通过原地合并优化空间占用。

特殊排序算法：场景化解决方案

计数排序（Counting Sort）

计数排序是一种非比较型整数排序算法，适用于一定范围的整数排序。CountingSort.java实现如下：

public void sort(int[] array) {
    int max = Arrays.stream(array).max().getAsInt();
    int min = Arrays.stream(array).min().getAsInt();
    int range = max - min + 1;
    
    int[] count = new int[range];
    int[] output = new int[array.length];
    
    for (int num : array) {
        count[num - min]++;
    }
    
    for (int i = 1; i < count.length; i++) {
        count[i] += count[i - 1];
    }
    
    for (int i = array.length - 1; i >= 0; i--) {
        output[count[array[i] - min] - 1] = array[i];
        count[array[i] - min]--;
    }
    
    System.arraycopy(output, 0, array, 0, array.length);
}

计数排序的时间复杂度为O(n + k)，其中k是整数的范围，适用于已知范围的整数排序场景。

堆排序（Heap Sort）

堆排序利用堆数据结构实现排序，HeapSort.java实现如下：

public void sort(int[] array) {
    int n = array.length;
    
    // 构建最大堆
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(array, n, i);
    }
    
    // 提取堆顶元素并重建堆
    for (int i = n - 1; i > 0; i--) {
        SortUtils.swap(array, 0, i);
        heapify(array, i, 0);
    }
}

private void heapify(int[] array, int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < n && array[left] > array[largest]) {
        largest = left;
    }
    
    if (right < n && array[right] > array[largest]) {
        largest = right;
    }
    
    if (largest != i) {
        SortUtils.swap(array, i, largest);
        heapify(array, n, largest);
    }
}

堆排序的时间复杂度为O(n log n)，不需要额外空间，适用于空间受限的场景。

排序算法性能对比

不同排序算法在时间复杂度、空间复杂度和稳定性方面各有特点，如下表所示：

排序算法	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
冒泡排序	O(n²)	O(n²)	O(1)	稳定
选择排序	O(n²)	O(n²)	O(1)	不稳定
插入排序	O(n²)	O(n²)	O(1)	稳定
快速排序	O(n log n)	O(n²)	O(log n)	不稳定
归并排序	O(n log n)	O(n log n)	O(n)	稳定
堆排序	O(n log n)	O(n log n)	O(1)	不稳定
计数排序	O(n + k)	O(n + k)	O(n + k)	稳定

实战应用：排序算法选择指南

在实际开发中，应根据数据特性选择合适的排序算法：

• 小规模数据：优先选择插入排序或冒泡排序
• 大规模随机数据：快速排序是首选
• 近乎有序数据：插入排序性能接近O(n)
• 稳定性要求高：归并排序或计数排序
• 空间受限场景：堆排序或快速排序

项目提供的SortAlgorithm.java接口定义了统一的排序算法接口，便于在实际项目中灵活切换不同排序实现：

public interface SortAlgorithm {
    <T extends Comparable<T>> T[] sort(T[] array);
}

总结与扩展学习

本文介绍了项目中常用的排序算法实现，包括基础排序、高级排序和特殊排序算法。通过学习src/main/java/com/thealgorithms/sorts/目录下的源码，你可以深入理解各种排序算法的实现细节和性能特点。

建议进一步学习：

• 分布式排序算法实现
• 外部排序算法设计
• 排序算法的并行化实现

项目的测试代码位于src/test/java/com/thealgorithms/sorts/目录，包含了各种排序算法的单元测试，可帮助你更好地理解算法的正确性验证方法。

【免费下载链接】Java All Algorithms implemented in Java 项目地址: https://gitcode.com/GitHub_Trending/ja/Java