七大基于比较的排序算法

目录

一、基于比较的排序算法概述

[1. 插入排序（Insertion Sort）](#1. 插入排序（Insertion Sort）)

[2. 选择排序（Selection Sort）](#2. 选择排序（Selection Sort）)

[3. 冒泡排序（Bubble Sort）](#3. 冒泡排序（Bubble Sort）)

[4. 归并排序（Merge Sort）](#4. 归并排序（Merge Sort）)

[5. 快速排序（Quick Sort）](#5. 快速排序（Quick Sort）)

[6. 堆排序（Heap Sort）](#6. 堆排序（Heap Sort）)

[7. 希尔排序（Shell Sort）](#7. 希尔排序（Shell Sort）)

二、排序算法的性能分析

三、Java中的常用排序方法

---

在计算机科学中，排序算法是处理数据结构的核心算法之一。它不仅直接影响程序的性能，还影响到数据的传输和存储效率。本文将深入探讨七种基于比较的排序算法，包括它们的基本原理、实现方法和性能分析，同时也会介绍Java中常用的排序方法。

一、基于比较的排序算法概述

基于比较的排序算法是指通过比较元素之间的大小关系来确定元素的排列顺序的算法。这类算法的时间复杂度下界为O(n log n)。根据不同的策略和实现，常见的基于比较的排序算法包括插入排序、选择排序、冒泡排序、归并排序、快速排序、堆排序以及希尔排序。以下对这七种排序算法进行详细介绍。

1. 插入排序（Insertion Sort）

原理

插入排序是一种简单且直观的排序算法。它通过构建一个有序的序列，将待排序的元素逐步插入到已排序序列中，直到所有元素都在正确的位置。

实现

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

性能分析

插入排序的时间复杂度为O(n²)，适合小规模数据的排序。其空间复杂度为O(1)，是一个原地排序算法。对几乎已经排序的数据集，其性能接近O(n)。

2. 选择排序（Selection Sort）

原理

选择排序通过反复选择未排序部分的最小元素，逐步将其放到已排序部分的末尾。

实现

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

性能分析

选择排序的时间复杂度为O(n²)，空间复杂度为O(1)。它不适合大规模数据排序，因为在最坏情况下仍然需要n²的比较次数。

3. 冒泡排序（Bubble Sort）

原理

冒泡排序通过重复遍历待排序的元素，比较相邻元素并根据大小关系进行交换，直到没有元素需要交换为止。

实现

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

性能分析

冒泡排序的时间复杂度为O(n²)，空间复杂度为O(1)。尽管实现简单，但由于其性能性能较差，通常不用于实际应用。

4. 归并排序（Merge Sort）

原理

归并排序采用分治法，将待排序数组分成两个子数组，分别对其进行排序后再合并成一个有序数组。实现

public static void mergeSort(int[] array) {  
    if (array.length < 2) {  
        return;  
    }  
    int mid = array.length / 2;  
    int[] left = Arrays.copyOfRange(array, 0, mid);  
    int[] right = Arrays.copyOfRange(array, mid, array.length);  
    mergeSort(left);  
    mergeSort(right);  
    merge(array, left, right);  
}  

private static void merge(int[] array, int[] left, int[] right) {  
    int i = 0, j = 0, k = 0;  
    while (i < left.length && j < right.length) {  
        if (left[i] <= right[j]) {  
            array[k++] = left[i++];  
        } else {  
            array[k++] = right[j++];  
        }  
    }  
    while (i < left.length) {  
        array[k++] = left[i++];  
    }  
    while (j < right.length) {  
        array[k++] = right[j++];  
    }  
}  

性能分析

归并排序的时间复杂度为O(n log n)，空间复杂度为O(n)。由于其稳定性和较优的性能，常用于大规模数据排序。

5. 快速排序（Quick Sort）

原理

快速排序也采用分治法，通过选择一个"基准"元素，将数组分成小于和大于基准的两个部分，递归地对这两个部分进行排序。实现

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

private static 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++;  
            int temp = array[i];  
            array[i] = array[j];  
            array[j] = temp;  
        }  
    }  
    int temp = array[i + 1];  
    array[i + 1] = array[high];  
    array[high] = temp;  
    return i + 1;  
}  

性能分析

快速排序的平均时间复杂度为O(n log n)，最坏情况为O(n²)（如已经有序数组），空间复杂度为O(log n)。快速排序在大多数情况下表现优秀，尤其适用于大规模数据排序。

6. 堆排序（Heap Sort）

原理

堆排序利用堆结构 以确定元素的顺序。首先构建一个最大堆，将堆顶元素与最后一个元素交换，缩小堆并调整已构建的堆。实现

public static void heapSort(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--) {  
        int temp = array[0];  
        array[0] = array[i];  
        array[i] = temp;  
        heapify(array, i, 0);  
    }  
}  

private static 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) {  
        int swap = array[i];  
        array[i] = array[largest];  
        array[largest] = swap;  
        heapify(array, n, largest);  
    }  
}  

性能分析

堆排序的时间复杂度为O(n log n)，空间复杂度为O(1)。由于其不稳定性，使用场景受到一定限制。

7. 希尔排序（Shell Sort）

原理

希尔排序是插入排序的一种改进版，通过使用间隔进行分组，实现对每组内的元素进行插入排序，从而最终达到整体有序。

实现

public static void shellSort(int[] array) {  
    int n = array.length;  
    for (int gap = n / 2; gap > 0; gap /= 2) {  
        for (int i = gap; i < n; i++) {  
            int temp = array[i];  
            int j;  
            for (j = i; j >= gap && array[j - gap] > temp; j -= gap) {  
                array[j] = array[j - gap];  
            }  
            array[j] = temp;  
        }  
    }  
}  

性能分析

希尔排序的时间复杂度取决于间隔序列的选择，通常在O(n log n)与O(n²)之间。具有不稳定性，适用于中等规模的数据排序。

二、排序算法的性能分析

排序算法的性能分析主要从时间复杂度和空间复杂度两个方面进行。

时间复杂度：描述算法执行所需时间与输入规模之间的关系。大多数已知的排序算法都具有O(n²)和O(n log n)的时间复杂度，差别主要体现在算法的实际常数因子以及适用的输入规模和分布特征。

空间复杂度：描述算法执行所需额外存储空间与输入规模之间的关系。原地排序算法（如堆排序、快速排序）在空间复杂度方面表现优异，而归并排序等需要额外存储空间的算法则性能较差，适用于内存充足的情况。

三、Java中的常用排序方法

在Java中，除了自定义实现的排序算法外，Java Collections框架也提供了多种高效的排序方法。例如，Arrays.sort()和Collections.sort()分别用于数组和集合的排序。这些排序方法通常使用的是优化后的快速排序算法，性能优越且易于使用。

Arrays.sort(array); // 数组排序  
Collections.sort(list); // 集合排序  

此外，在Java 8及其之后的版本中引入了并行流（parallel streams），以支持并行排序，通过更好地利用多核处理器资源来提高排序性能。