你用过哪些排序?
日常工作中用到的排序可能就冒泡排序用的最多，其他排序比如选择排序，插入排序，快速排序，归并排序等用的很少，或者很多情况下压根儿都不清楚这些排序的原理，今天我们来盘它。
常见的几种排序如下
- 冒泡排序
- 选择排序
- 插入排序
- 快速排序
- 归并排序
- 堆排序
- 希尔排序
- 计数排序
- 桶排序
- 基数排序
1 冒泡排序
冒泡排序是一种简单的排序算法，排序的原理是比较相邻的元素，如果前一个元素大于后一个元素，则交换这两个元素。通过多次遍历数组，将最大的元素逐步“冒泡”到数组的末尾。
通过代码实现
public static void bubbleSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// 交换相邻元素
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
结果如下:
int[] arr = {5, 2, 8, 4, 7};
bubbleSort(arr);
System.out.println(Arrays.toString(arr)); // [2, 4, 5, 7, 8]
2 选择排序
选择排序的原理是每次从待排序的序列中选出最小的元素，然后放到已排序序列的末尾，直到所有元素都排好序为止。
通过代码实现:
public static void selectionSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
结果如下:
int[] arr = {5, 2, 8, 4, 7};
selectionSort(arr);
System.out.println(Arrays.toString(arr)); // [2, 4, 5, 7, 8]
3 插入排序
插入排序是一种简单直观的排序算法，排序原理是将待排序的元素插入到已排序序列中的适当位置，使之成为新的有序序列。其过程类似于打扑克牌时，将新抽的牌插入到已经有序的牌中。
代码实现如下:
public static void insertionSort(int[] arr) {
int n = arr.length;
for (int i = 1; i < n; 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;
}
}
结果:
int[] arr = { 5, 2, 4, 6, 1, 3 };
insertionSort(arr);
System.out.println(Arrays.toString(arr));
4 快速排序
快速排序的原理是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均小于另一部分记录的关键字，然后再分别对这两部分记录进行排序，以达到整个序列有序的目的。
快速排序的步骤如下：
- 选择一个基准元素，通常选择第一个元素或者最后一个元素。
- 将所有小于基准元素的元素移动到基准元素的左边，所有大于基准元素的元素移动到基准元素的右边。
- 对基准元素左右两边的子序列分别进行递归排序。
下面通过代码实现
public class QuickSort {
public static void quickSort(int[] arr, int left, int right) {
if (left < right) {
int pivotIndex = partition(arr, left, right); // 基准元素的位置
quickSort(arr, left, pivotIndex - 1); // 对基准元素左边的子序列进行递归排序
quickSort(arr, pivotIndex + 1, right); // 对基准元素右边的子序列进行递归排序
}
}
private static int partition(int[] arr, int left, int right) {
int pivot = arr[left]; // 基准元素
int i = left + 1, j = right;
while (true) {
while (i <= j && arr[i] < pivot) i++;
while (i <= j && arr[j] > pivot) j--;
if (i >= j) break;
swap(arr, i, j);
i++;
j--;
}
swap(arr, left, j); // 将基准元素放到正确的位置上
return j;
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
结果:
int[] arr = {5, 3, 8, 4, 2, 7, 1, 10, 6, 9};
QuickSort.quickSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
5 归并排序
归并排序是一种基于分治思想的排序算法，它的排序原理是将待排序数组不断分割成两个子数组，直到每个子数组只有一个元素，然后将这些子数组按照从小到大的顺序合并成一个有序的数组。具体实现过程如下：
- 将待排序数组分割成两个子数组，分别对两个子数组进行归并排序。
- 将两个有序的子数组合并成一个有序的数组。
在合并两个有序子数组的过程中，可以使用双指针的方法，分别指向两个子数组的头部，比较两个指针所指的元素大小，将较小的元素放入新的数组中，然后移动指针，直到其中一个子数组的元素全部放入新的数组中，然后将另一个子数组的剩余元素依次放入新的数组中。
下面通过代码实现如下:
public class MergeSort {
public static void mergeSort(int[] arr, int left, int right) {
if (left >= right) {
return;
}
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
public 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) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
while (i <= mid) {
temp[k++] = arr[i++];
}
while (j <= right) {
temp[k++] = arr[j++];
}
for (int p = 0; p < temp.length; p++) {
arr[left + p] = temp[p];
}
}
public static void main(String[] args) {
int[] arr = {5, 2, 4, 6, 1, 3};
mergeSort(arr, 0, arr.length - 1);
for (int i : arr) {
System.out.print(i + " ");
}
}
}
调用结果
1 2 3 4 5 6
6 堆排序
堆排序是一种基于二叉堆的排序算法，排序原理如下：
-
将待排序的序列构建成一个大顶堆（或小顶堆），此时整个序列的最大值（或最小值）就是堆顶的根节点。
-
将堆顶元素与堆末尾元素交换，并将堆的长度减1，此时堆顶元素就被放到了序列的末尾，然后重新调整堆，使其满足堆的性质。
-
重复第2步，直到堆的长度为1，此时整个序列就被排序完成了。
下面通过代码实现:
public static void heapSort(int[] arr) {
// 1. 构建大顶堆
for (int i = arr.length / 2 - 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
// 2. 调整堆结构+交换堆顶元素与末尾元素
for (int j = arr.length - 1; j > 0; j--) {
swap(arr, 0, j);
adjustHeap(arr, 0, j);
}
}
private static void adjustHeap(int[] arr, int i, int length) {
int temp = arr[i]; // 先取出当前元素i
for (int k = i * 2 + 1; k < length; k = k * 2 + 1) { // 从i结点的左子结点开始，也就是2i+1处开始
if (k + 1 < length && arr[k] < arr[k + 1]) { // 如果左子结点小于右子结点，k指向右子结点
k++;
}
if (arr[k] > temp) { // 如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
arr[i] = arr[k];
i = k;
} else {
break;
}
}
arr[i] = temp; // 将temp值放到最终的位置
}
private static void swap(int[] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
结果:
int[] arr = { 5, 3, 9, 1, 7, 2, 8, 4, 6 };
heapSort(arr);
System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6, 7, 8, 9]
7 希尔排序
希尔排序是一种插入排序的改进版，也称为缩小增量排序。它的实现原理是将待排序的数组元素按照一定的间隔分成若干个子序列，对每个子序列进行插入排序，然后不断缩小间隔，直到间隔为1，最后对整个序列进行一次插入排序。
具体实现步骤如下：
- 选择一个增量序列，通常选择希尔增量，也可以选择其他增量序列。
- 按照增量序列将待排序的数组分成若干个子序列。
- 对每个子序列进行插入排序。
- 不断缩小增量，重复步骤2和3，直到增量为1。
下面是代码实现案例:
public static void shellSort(int[] arr) {
int len = arr.length;
int gap = len / 2;
while (gap > 0) {
for (int i = gap; i < len; i++) {
int temp = arr[i];
int j = i;
while (j >= gap && arr[j - gap] > temp) {
arr[j] = arr[j - gap];
j -= gap;
}
arr[j] = temp;
}
gap /= 2;
}
}
结果:
int[] arr = {5, 2, 8, 3, 1, 6};
shellSort(arr);
System.out.println(Arrays.toString(arr));//[1, 2, 3, 5, 6, 8]
8 计数排序
计数排序是一种非比较排序算法，它的原理是统计每个元素在序列中出现的次数，然后根据统计结果将元素排列成有序序列。
具体的实现步骤如下：
- 计算每个元素在序列中出现的次数，存储在一个计数数组中。
- 对计数数组进行累加，得到每个元素在有序序列中的位置。
- 根据计数数组中的位置信息，将元素放置到有序序列中。
- 输出有序序列。
下面是一个代码案例
public static void countingSort(int[] arr) {
if (arr == null || arr.length <= 1) {
return;
}
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
int[] count = new int[max + 1];
for (int i = 0; i < arr.length; i++) {
count[arr[i]]++;
}
for (int i = 1; i < count.length; i++) {
count[i] += count[i - 1];
}
int[] sorted = new int[arr.length];
for (int i = arr.length - 1; i >= 0; i--) {
sorted[--count[arr[i]]] = arr[i];
}
System.arraycopy(sorted, 0, arr, 0, arr.length);
}
结果:
int[] arr = {5, 2, 3, 1, 4};
countingSort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5]
可以看到，输入的无序数组经过计数排序之后，输出的数组已经排列成有序序列。
9 桶排序
桶排序的原理是将要排序的数据分到几个有序的桶里，每个桶里的数据再单独进行排序。桶排序的核心思想是将数据分到尽量多的桶中，使得每个桶中的数据尽量少，从而提高排序的效率。
具体的实现步骤如下：
-
确定桶的个数，以及每个桶的范围。
-
遍历要排序的数据，将数据放入对应的桶中。
-
对每个桶中的数据进行排序，可以使用其他排序算法，也可以递归使用桶排序。
-
将每个桶中的数据按顺序合并到一起，输出有序序列。
public static void bucketSort(int[] arr, int bucketSize) { if (arr == null || arr.length <= 1) { return; }
int min = arr[0]; int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] < min) { min = arr[i]; } else if (arr[i] > max) { max = arr[i]; } } int bucketCount = (max - min) / bucketSize + 1; List<List<Integer>> buckets = new ArrayList<>(bucketCount); for (int i = 0; i < bucketCount; i++) { buckets.add(new ArrayList<>()); } for (int i = 0; i < arr.length; i++) { int bucketIndex = (arr[i] - min) / bucketSize; buckets.get(bucketIndex).add(arr[i]); } int index = 0; for (int i = 0; i < bucketCount; i++) { List<Integer> bucket = buckets.get(i); if (bucket.isEmpty()) { continue; } int[] bucketArr = new int[bucket.size()]; for (int j = 0; j < bucket.size(); j++) { bucketArr[j] = bucket.get(j); } if (bucketSize == 1) { // 如果桶大小为1，则桶内数据已经有序 System.arraycopy(bucketArr, 0, arr, index, bucketArr.length); index += bucketArr.length; } else { // 否则递归使用桶排序 bucketSort(bucketArr, bucketSize / 2); System.arraycopy(bucketArr, 0, arr, index, bucketArr.length); index += bucketArr.length; } }}
结果：
int[] arr = {5, 2, 3, 1, 4};
bucketSort(arr, 2);
System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5]
10 基数排序
基数排序的原理是将待排序的数字按照个位、十位、百位等位数逐个排序，最终得到有序的结果。基数排序的时间复杂度为O(d(n+k))，其中n为待排序的数字个数，k为数字的取值范围，d为数字的位数。
以下是代码案例
public static void radixSort(int[] arr) {
if (arr == null || arr.length == 0) {
return;
}
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
int exp = 1;
int[] aux = new int[arr.length];
while (max / exp > 0) {
int[] count = new int[10];
for (int i = 0; i < arr.length; i++) {
count[(arr[i] / exp) % 10]++;
}
for (int i = 1; i < 10; i++) {
count[i] += count[i - 1];
}
for (int i = arr.length - 1; i >= 0; i--) {
aux[--count[(arr[i] / exp) % 10]] = arr[i];
}
for (int i = 0; i < arr.length; i++) {
arr[i] = aux[i];
}
exp *= 10;
}
}
我们首先找到待排序数组中的最大值max，然后从个位开始依次对数字进行排序，直到排完最高位。在每一轮排序中，我们需要使用计数排序来对数字进行排序，并将排序结果存储在一个辅助数组aux中，最后将aux中的结果复制回原数组arr中。
结果:
int[] arr = {53, 3, 542, 748, 14, 214, 154, 63, 616};
radixSort(arr);
System.out.println(Arrays.toString(arr));//[3, 14, 53, 63, 154, 214, 542, 616, 748]
结尾
在编程中，排序是一项非常重要的技能，它可以帮助我们更高效地处理数据，提高程序的性能。无论是在算法竞赛中还是实际的开发中，排序都是必须掌握的基本技能之一。通过不断学习和实践，我们可以不断提高自己的排序算法水平，为自己的编程之路铺平道路。让我们一起努力，让自己变得更优秀！
