常见的排序算法（Java）

排序算法：基本概念与分类

1. 引言

排序是计算机科学中最基本且最重要的算法之一。它在数据处理和算法设计中扮演着关键角色。本文将介绍排序算法的基本概念、分类以及常见排序算法的特点，并提供简单的 Java 实现示例。

2. 排序的基本概念

2.1 定义

排序是将一组数据按照特定顺序重新排列的过程。通常将数据排列成升序或降序。

2.2 性能指标

评价排序算法的主要指标包括：

时间复杂度：算法执行所需的时间。
空间复杂度：算法执行所需的额外空间。
稳定性：相同键值的元素在排序前后的相对位置是否发生变化。

3. 排序算法的分类

排序算法可以从多个角度进行分类：

3.1 基于比较的排序 vs 非比较排序

基于比较的排序：通过比较元素间的相对大小进行排序。例如：冒泡排序、插入排序、快速排序等。
非比较排序：不通过比较元素进行排序。例如：计数排序、基数排序、桶排序等。

3.2 内部排序 vs 外部排序

内部排序：所有数据都加载到内存中进行排序。
外部排序：数据太大，无法全部加载到内存，需要使用外部存储。

3.3 稳定排序 vs 不稳定排序

稳定排序：保持相等元素的相对顺序。
不稳定排序：不保证保持相等元素的相对顺序。

4. 常见排序算法概览

4.1 冒泡排序 (Bubble Sort)

基本思想：重复遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定

public static void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

4.2 选择排序 (Selection Sort)

基本思想：每次从未排序部分选择最小元素，放到已排序部分的末尾。
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：不稳定

public static void selectionSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

4.3 插入排序 (Insertion Sort)

基本思想：将一个元素插入到已经排好序的有序表中。
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定

public static void insertionSort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

4.4 快速排序 (Quick Sort)

基本思想：选择一个基准元素，将数组分为两部分，一部分比基准小，另一部分比基准大。
时间复杂度：平均 O(n log n)，最坏 O(n^2)
空间复杂度：O(log n)
稳定性：不稳定

public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 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++;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    int temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return i + 1;
}

4.5 归并排序 (Merge Sort)

基本思想：将数组分成两半，分别排序，然后合并两个有序数组。
时间复杂度：O(n log n)
空间复杂度：O(n)
稳定性：稳定

public static void mergeSort(int[] arr, int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

private static void merge(int[] arr, int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;
    int[] L = new int[n1];
    int[] R = new int[n2];
    for (int i = 0; i < n1; ++i) L[i] = arr[l + i];
    for (int j = 0; j < n2; ++j) R[j] = arr[m + 1 + j];
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

5. 排序算法的选择

选择合适的排序算法取决于多个因素：

数据规模：对于小规模数据，简单算法如插入排序可能更快；对于大规模数据，应选择如快速排序、归并排序等高效算法。
数据分布：某些算法在特定数据分布下表现更好。
稳定性要求：如果需要保持相等元素的相对顺序，应选择稳定的排序算法。
空间限制：在内存受限的情况下，应选择原地排序算法。
是否接近有序：对于接近有序的数据，插入排序可能是很好的选择。

6. 总结

排序算法是计算机科学中的基础，理解不同排序算法的特点和适用场景对于选择合适的算法解决实际问题至关重要。在实际应用中，我们通常会使用语言或框架提供的标准库实现（如 Java 的 Arrays.sort()），这些实现通常经过了优化，能够适应各种情况。然而，理解这些算法的原理仍然是很重要的，因为它可以帮助我们在特定场景下做出更好的选择或进行自定义优化。

posted @ 2024-08-06 10:06 KenWan 阅读(63) 评论(0) 收藏举报

刷新页面返回顶部

KenWan