Java中的六种经典比较排序算法

一、 前言

1.1 引入

排序算法是程序开发和计算机科学中常见的算法之一。排序算法可以对一个未排序的数据集合进行排序，使得数据集合中的元素按照一定的顺序排列。排序算法是算法分析的重要内容之一，因为排序算法的效率影响着程序的性能和稳定性。

1.2 目的

本文的目的是介绍常见的排序算法，并且通过代码示例演示它们的实现过程。本文会逐一介绍冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序等六种排序算法，并对它们的原理、思路、代码实现及时间复杂度进行详细分析。最后通过性能比较实验，比较这些算法在不同数据规模下的耗时情况，从而得出各种算法的优劣。

二、 排序算法概述

2.1 什么是排序算法

排序算法是一种对数据集合进行排序的算法，按照某种顺序重新排列数据集合中的元素。排序算法可以应用于各种领域，例如程序开发、数据库查询优化等。

2.2 排序算法分类

常见的排序算法可分为以下几类：

（1）比较排序：通过比较数据集合中元素的大小关系来进行排序。比较排序算法包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序等。

（2）非比较排序：不需要比较数据集合中元素的大小关系来进行排序，而是通过类似于哈希表的方式将数据集合中的元素进行分配。非比较排序算法包括计数排序、桶排序、基数排序等。

2.3 排序算法比较

不同的排序算法有不同的时间复杂度和空间复杂度，不同的应用场景需要选择不同的排序算法。下表列出了常见的排序算法，以及它们的时间复杂度和空间复杂度。

这些是时间复杂度的表示法，常常用来衡量算法的效率和实用性：

根据表格中的数据，我们可以得出一些结论：

（1）冒泡排序、选择排序和插入排序虽然实现简单，但其时间复杂度都比较高，不适合处理大规模的数据集合。

（2）希尔排序的时间复杂度比较稳定，是一种比较实用的排序算法。

（3）归并排序和快速排序都是基于分治思想的排序算法，它们的时间复杂度比较低，是处理大规模数据集合的不二选择。

三、 冒泡排序

3.1 原理与思想

冒泡排序是一种比较简单的排序算法，它重复地遍历要进行排序的数组，比较相邻两个元素的大小，如果前一个元素大于后一个元素，则交换它们的位置。这样一遍遍历下来，每次都将数组中最大的元素“冒泡”到最后面。如此操作，直到所有元素都排列好位置。

3.2 代码实现

下面是冒泡排序的代码实现：

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

3.3 时间复杂度分析

时间复杂度的表示法的含义可以在2.3查看 冒泡排序的时间复杂度为 O(n^2)，因此在处理大规模数据时，效率较低。具体来说，最坏情况下需要执行 n*(n-1)/2 次比较和交换，而最优情况下则只需要执行 n-1 次比较和 0 次交换。在平均情况下，冒泡排序需要执行 n*(n-1)/4 次比较和交换。由于时间复杂度为 O(n^2)，因此冒泡排序不适合处理大规模数据的排序问题，但由于其思想简单，实现容易，并且常常被用作教学用例，以帮助学生理解排序算法的基本原理。

四、 选择排序

4.1 原理与思想

选择排序是一种简单直观的排序算法，它的基本思想是：每次在待排序的数组中选取最小的元素，然后把它和数组的第一个元素交换位置，接着在剩下的元素中再选取最小的元素，放在已排好序的数组的最后面。如此操作，直到所有元素都排列好位置。

4.2 代码实现

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

4.3 时间复杂度分析

时间复杂度的表示法的含义可以在2.3查看

选择排序的时间复杂度为 O(n^2)，因此与冒泡排序一样，不适合处理大规模数据的排序问题。具体来说，在平均情况下需要执行 n*(n-1)/2 次比较和 n-1 次交换。在最坏情况下，需要执行 n*(n-1)/2 次比较和 n-1 次交换。在最优情况下，也需要执行 n*(n-1)/2 次比较和 0 次交换。虽然时间复杂度比较高，但实现简单，不占用额外的内存空间。

五、 插入排序

5.1 原理与思想

插入排序是一种简单直观的排序算法，它的基本思想是：将待排序的数组分为已排好序的部分和未排序的部分，从未排序的部分中取出一个元素插入到已排好序的部分中，使得插入后仍然有序。如此操作，直到所有元素都排列好位置。

5.2 代码实现

public class InsertionSort {
public static void main(String[] args) {
int[] arr = {5, 2, 4, 6, 1, 3};
    insertionSort(arr);
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i] + " ");
    }
}
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 = j - 1;
        }
        arr[j + 1] = key;
    }
}
}

5.3 时间复杂度分析

时间复杂度的表示法的含义可以在2.3查看

对于插入排序，时间复杂度取决于需要进行排序的数据的数量以及数据的状态。最好情况下，当数据已经按照从小到大的顺序排序时，插入排序的时间复杂度为O(n)。最坏情况下，当数据以从大到小的顺序排序时，插入排序的时间复杂度为O(n^2)。由于插入排序在大多数情况下执行效率很高，因为它仅仅需要比较少量的元素。

六、 希尔排序

6.1 原理与思想

希尔排序的基本思想是，先将待排序的数组按照步长d分成多个子序列，然后分别对每个子序列进行插入排序，然后缩小步长d，再进行排序，直到步长为1为止。

具体实现中，步长可以按照某种规律确定，通常以序列长度的一半作为初始步长，然后每次将步长减半，直至步长为1。

例如，对于一个序列{8,34,56,78,12,57,89,43}，选择步长为4：

• 首先，将序列分为四个子序列：{8,57}，{34,89}，{56,43}，{78,12}。

• 然后，对于每个子序列，分别进行插入排序。

• 接下来，将步长缩小至2，将序列分成两个子序列：{8,89,56,12}，{34,57,78,43}。

• 上述操作持续进行，直至步长为1，最终对整个序列进行一次插入排序，完成排序。

6.2 代码实现

public class ShellSort {
public static void main(String[] args) {
int[] arr = {5, 2, 4, 6, 1, 3};
    shellSort(arr);
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i] + " ");
    }
}
public static void shellSort(int[] arr) {
    int n = arr.length;
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int key = arr[i];
            int j = i;
            while (j >= gap && arr[j - gap] > key) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = key;
        }
    }
}
}

6.3 时间复杂度分析

时间复杂度的表示法的含义可以在2.3查看 希尔排序的时间复杂度与步长的选择有关，但是目前还没有一种确定最优步长的方法，也就是说，希尔排序的时间复杂度依赖于具体的步长序列。

目前已知最优步长序列的时间复杂度为O(n^1.3)，即当步长序列为1, 4, 13, 40, ...时，希尔排序的时间复杂度最优。

但是，希尔排序的时间复杂度最坏为O(n^2)，最好为O(nlogn)。

七、 归并排序

7.1 原理与思想

归并排序采用分治策略，它将问题划分为较小的问题，并递归地解决每个子问题。具体来说，归并排序的过程包括两个主要步骤：

• 分割：将待排序数组拆分为两个长度相等的子数组，这一步骤通过递归调用归并排序来实现。
• 合并：将已排序的两个子数组合并为一个有序的数组。这一步骤通过比较两个待比较的元素，然后按顺序将它们放入一个新的数组中来实现。

7.2 代码实现

public static void mergeSort(int[] nums) {
    if (nums == null || nums.length < 2) {
        return;
    }
    int mid = nums.length / 2;
    int[] left = Arrays.copyOfRange(nums, 0, mid);
    int[] right = Arrays.copyOfRange(nums, mid, nums.length);
    mergeSort(left);
    mergeSort(right);
    merge(nums, left, right);
}
private static void merge(int[] nums, int[] left, int[] right) {
    int i = 0, j = 0, k = 0;
    while (i < left.length && j < right.length) {
        if (left[i] <= right[j]) {
            nums[k++] = left[i++];
        } else {
            nums[k++] = right[j++];
        }
    }
    while (i < left.length) {
        nums[k++] = left[i++];
    }
    while (j < right.length) {
        nums[k++] = right[j++];
    }
}

在上面的代码中，mergeSort方法用于递归地分割数组，并调用merge方法在合适的位置上合并这些分割后的数组。merge方法比较分割后的数组的元素，并将它们按照顺序放入一个新的数组中。

7.3 时间复杂度分析

时间复杂度的表示法的含义可以在2.3查看 归并排序的时间复杂度为O(nlogn)，其中n是待排序数组的长度。归并排序的时间复杂度是基于分治策略的，它将问题拆分为较小的子问题，然后递归地解决这些子问题。因此，归并排序的时间复杂度与子问题的数量相关。每次递归把数组分成两半，因此将生成O(logn)层。在每一层中，需要比较和合并O(n)个元素。因此，总体复杂度为O(nlogn)。

八、 快速排序

8.1 原理与思想

快速排序也采用了分治策略。与归并排序不同的是，快速排序是在分割数组的同时对其进行排序的。具体来说，快速排序的过程包括以下步骤：

• 选择主元素：从数组中选择一个元素作为主元素，并根据它对数组进行分区。
• 分区：将比主元素小的元素放在主元素的左侧，将比主元素大的元素放在主元素的右侧。这一步骤可以使用左右指针来实现。
• 递归：递归地应用快速排序算法，直到所有子数组都有序。

8.2 代码实现

public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        if (low >= high) {
            return;
        }
        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[low];
        int i = low + 1, j = high;
        while (true) {
            while (i <= j && arr[i] <= pivot) {
                i++;
            }
            while (i <= j && arr[j] >= pivot) {
                j--;
            }
            if (i > j) {
                break;
            }
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        arr[low] = arr[j];
        arr[j] = pivot;
        return j;
    }
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2, 7, 1, 6};
        quickSort(arr, 0, arr.length - 1);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

代码中首先定义了一个quickSort方法，传入待排序序列及序列的起始下标low和结束下标high。如果low>=high，则递归结束。否则，调用partition方法，将序列分为左右两部分。然后对左右两部分分别进行递归排序，直到整个序列有序。

partition方法是快速排序算法的核心。选择第一个元素作为基准元素pivot，定义i=low+1，j=high。从左往右扫描，找到第一个大于pivot的元素，将其与从右往左扫描找到的第一个小于pivot的元素交换位置。如果i>j，说明扫描完成，退出循环。最后将基准元素移动到i-1的位置，返回i-1。

8.3 时间复杂度分析

时间复杂度的表示法的含义可以在2.3查看 快速排序的平均时间复杂度为O(nlogn)，最坏时间复杂度为O(n^2)，空间复杂度为O(logn)。不过由于快速排序是原地排序算法，不需要额外的存储空间。

在最坏情况下，即待排序序列已经有序，且基准元素选择的是序列中的最大或最小值，每次只将序列中的一个元素移动到了正确的位置，时间复杂度为O(n^2)。但是这种情况很少出现，可以通过优化基准元素的选择和递归排序的顺序来减少出现最坏情况的概率。

九、 性能比较

9.1 实验设计

在本次实验中，我们比较了冒泡排序、选择排序、插入排序、希尔排序、归并排序和快速排序这六种不同的排序算法在处理不同规模数据时所需的时间。我们随机生成了 10 个不同规模的数据集，并对各个算法在每个数据集上的运行时间进行了测试。

实验数据集规模如下：

• 数据集1：10,000 个元素
• 数据集2：20,000 个元素
• 数据集3：30,000 个元素
• 数据集4：40,000 个元素
• 数据集5：50,000 个元素
• 数据集6：60,000 个元素
• 数据集7：70,000 个元素
• 数据集8：80,000 个元素
• 数据集9：90,000 个元素
• 数据集10：100,000 个元素

9.2 实验结果分析

根据实验结果，不同的排序算法在处理不同规模数据时的表现不同。在排序算法的性能比较中，时间复杂度是一个重要的指标。根据时间复杂度的定义，时间复杂度越低的算法，执行效率越高。下面是各个算法在处理不同规模数据时的平均运行时间（单位：秒）：

由上表可以看出，在处理相同规模的数据时，快速排序算法的表现最好，时间复杂度最低，所需时间最少。希尔排序的性能也表现得相当不错。而冒泡排序的时间复杂度最高，在处理大规模数据时效率极低。选择排序和插入排序的时间复杂度较高，效率也不如其他算法。

十、 总结与启示

10.1 总结

排序算法是计算机科学中非常基础和重要的算法，其目的是把一组无序的数据按照一定规则排成有序的数据序列。本文介绍了冒泡排序、选择排序、插入排序、希尔排序、归并排序和快速排序等六种基本的排序算法，以及它们的原理、代码实现和时间复杂度分析。

在时间效率上，快速排序是最快的排序算法，其时间复杂度为 O(nlogn)。但在数据规模比较小的情况下，插入排序和冒泡排序表现得更好。在空间效率上，插入排序是最好的，因为它只需要在数组中进行元素交换，而不需要额外使用数据结构。

另外，排序算法的实现不仅仅包括算法本身的复杂度，还需要考虑实现的复杂度。例如，使用递归实现快速排序会造成函数调用的开销，并且会消耗额外的内存。但如果使用迭代的方式实现快速排序，可以避免这些问题。

10.2 启示

排序算法是计算机科学非常基础和重要的算法。通过学习和掌握排序算法，我们可以深入理解算法的设计思想和性质，并且可以将这些思想和性质应用到其他的算法中。另外，在面试和竞赛中，对排序算法的掌握也是非常重要的。

在实际工作中，对于需要排序的数据，我们通常可以使用内置的排序函数或者第三方库进行排序。但对于一些特殊的需求，例如需要实现自定义的排序规则或者对大规模数据进行排序等，我们需要深入理解排序算法，并且根据数据规模、数据分布等因素选择合适的排序算法。

以上就是Java中的六种经典比较排序算法的详细内容，更多关于Java比较排序算法的资料请关注脚本之家其它相关文章！

最新评论