前言
如图是对基于比较排序算法的归纳,其余还有非基于比较的排序如计数排序、基数排序和桶排序。
这里主要介绍前五种(插入、希尔、选择、堆排序、冒泡)排序比较简单的排序。
一、插入排序
插入排序是一种简单直观的排序算法,其基本思想是将待排序的序列分为已排序和未排序两部分,每次从未排序的部分中选取一个元素插入到已排序的部分中,直到所有元素都被插入完毕。
具体来说,对于一个待排序的序列,插入排序的过程如下:
1、将第一个元素视为已排序部分
2、依次将未排序部分中的元素插入到已排序部分中,使得已排序部分仍然有序
3、直到未排序部分中所有元素都被插入完毕,排序完成
在插入排序的过程中,每次插入一个元素时,需要将其与已排序部分中的元素进行比较,并找到插入位置。为了将元素插入到正确位置,需要将已排序部分中的元素向后移动,以便腾出插入位置。
由于插入排序在每次插入时都需要将已排序部分中的元素向后移动,因此在最坏情况下,插入排序的时间复杂度为O(n^2)。但是,在实际应用中,插入排序常常被用作快速排序等其他高级排序算法的辅助排序算法。
对代码来说,从第二个元素开始,每次取tmp保存待排序元素,将待排序元素和它前面的所有元素逐一比较,直到确定插入位置
//直接插入排序
public static void insectSort(int[] array) {
for (int i = 1; i < array.length; i++) {
//拿到要插入的数
int tmp = array[i];
int j = i - 1;
for (; j >= 0; j--) {
//无序,加不加等于号会改变稳定性
if (array[j] > tmp) {
array[j + 1] = array[j];
} else {
break;
}
}
array[j + 1] = tmp;
}
}
解读:tmp为待插入元素,内层循环往前遍历,大于tmp的元素应该往后走一位;反之,由于当前已经有序,前面元素本就有序,不需要继续比较
二、希尔排序
希尔排序法又称缩小增量法。希尔排序法的基本思想是:先选定一个整数,把待排序文件中所有记录分成多个组,所有距离为的记录分在同一组内,并对每一组内的记录进行排序。然后,取,重复上述分组和排序的工作。当到达=1时,所有记录在统一组内排好序。
插入排序的分组是跳跃性的分组:1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序,目的是让数组更接近于有序。当gap == 1时,数组已经接近有序的了,这样就会很快。这样整体而言,可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算,因为gap的取值方法很多,导致很难去计算
//希尔排序
public static void shellSwap(int[] array) {
int gap = array.length / 2;
while (gap >= 1) {
shell(array, gap);
gap /= 2;
}
}
private static void shell(int[] array, int gap) {
//直接遍历,其中每个元素都对自己的组内进行排序
for (int i = gap; i < array.length; i++) {
int tmp = array[i];
int j = i - gap;
for (; j >= 0; j -= gap) {
if (array[j] > tmp) {
array[j + gap] = array[j];
} else {
break;
}
}
array[j + gap] = tmp;
}
}
解读:代码很简单,和插入排序基本一致。每次插入排序根据gap的不同取值和每次缩小而更趋近于有序,直到gap=1插入排序后使得最终有序。
三、选择排序
选择排序非常直观好理解,但是效率很低,实际中基本不使用。
基本思想:
每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完 。
- 在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
若它不是这组元素中的最后一个(第一个)元素,则将它与这组元素中的最后一个(第一个)元素交换
在剩余的array[i]–array[n-2](array[i+1]–array[n-1])集合中,重复上述步骤,直到集合剩余1个元素
public static void selectSort(int[] array) {
//记录最小值下标,从左到右依次有序
for (int i = 0; i < array.length; i++) {
int minIdx = i;
for (int j = i + 1; j < array.length; j++) {
if (array[j] < array[minIdx]) {
minIdx = j;
}
}
swap(array, i, minIdx);
}
}
private static void swap(int[] array, int i, int j) {
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
解读:非常简单直观,每次记录最小值下标,使从左至右依次有序。但是效率低的问题从代码上看也很明显,下面有一个优化后的选择排序。
//选择排序优化
public static void selectSortOptimization(int[] array) {
int left = 0;
int right = array.length - 1;
while (left < right) {
int minIdx = left;
int maxIdx = right;
//同时找最大值和最小值,分别放到right和left的位置,即排序后的最大最小位置
for (int i = left; i <= right; i++) {
if (array[i] < array[minIdx]) {
minIdx = i;
}
if (array[i] > array[maxIdx]) {
maxIdx = i;
}
}
swap(array, left, minIdx);
//如果最大值在left,此时left和最小值位置交换,最小值位置存放最大值
if (left == maxIdx) {
maxIdx = minIdx;
}
swap(array, right, maxIdx);
left++;
right--;
}
}
private static void swap(int[] array, int i, int j) {
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
解读:每次遍历同时记录最小和最大值,分别放在首和尾处,每次遍历就使两个元素完全有序。
特殊情况:
- 由于最左侧(left)位置是待交换的最小值位置,当最大值在这个位置时,会导致最大值先被minIdx位置的元素交换。
所以在交换该次最大值时,最大值位置在minIdx,即maxIdx应更新为minIdx
四、堆排序
堆排序在上一篇博客【优先级队列(堆)】中已有介绍。
总结两步:
1、创建大顶堆
2、依次将堆顶元素和堆底交换,使堆底有序,再对堆顶向下调整
这里给出完整代码:
/**
* 堆排序:
* 时间复杂度:O(N*logN)
* 空间复杂度:O(1)
* 稳定性:不稳定的排序
*/
public static void headSort(int[] array) {
//1.创建大顶堆
createHeap(array);
//2.每次将堆顶元素和堆底交换,再对堆顶向下调整
int end = array.length - 1;
while (end > 0) {
swap(array, 0, end);//从后往前放最大值
siftDown(array, 0, end - 1);
end--;
}
}
private static void createHeap(int[] array) {
//从最后的父节点开始,逐个向下调整
for (int parent = (array.length - 1 - 1) / 2; parent >= 0; parent--) {
siftDown(array, parent, array.length - 1);
}
}
private static void siftDown(int[] array, int parent, int end) {
int child = parent * 2 + 1;
while (child <= end) {
if (child + 1 <= end && array[child + 1] > array[child]) {
child++;
}
if (array[parent] < array[child]) {
swap(array, parent, child);
parent = child;
child = 2 * parent + 1;
} else {
break;
}
}
}
private static void swap(int[] array, int i, int j) {
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
五、冒泡排序
冒泡排序是一种非常容易理解的排序,在初学编程时,我们使用的排序就是冒泡排序。
总结一句话:趟数为数组长度-1,每次遍历将一个最大值移动到数组尾部,即从尾到头依次有序。
//冒泡排序
public static void bubbleSort(int[] array) {
//从前往后每次调整一个最大元素到末尾
for (int i = 0; i < array.length; i++) {
boolean flag = false;
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j + 1] < array[j]) {
swap(array, j, j + 1);
flag = true;
}
}
//没交换,表示已经有序
if (!flag) {
return;
}
}
}
private static void swap(int[] array, int i, int j) {
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
这里做出了一个优化,如果在一趟遍历中一次都没交换,说明这些元素已经有序了。
五种排序的力扣OJ通过情况
力扣链接:912.排序数组
除希尔排序和堆排序外,其余3种排序均超出时间限制;
希尔排序:
堆排序: