📑打牌 ： da pai ge的个人主页
🌤️个人专栏 ： da pai ge的博客专栏
☁️宝剑锋从磨砺出，梅花香自苦寒来
📑插入排序
📑**直接插入排序-**原理
整个区间被分为
- 有序区间
- 无序区间
每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入
📑实现
public static void insertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
// 有序区间: [0, i)
// 无序区间: [i, array.length)
int v = array[i]; // 无序区间的第一个数
int j = i - 1;
// 不写 array[j] == v 是保证排序的稳定性
for (; j >= 0 && array[j] > v; j--) {
array[j + 1] = array[j];
}
array[j + 1] = v;
}
}
时间复杂度
空间复杂度
最好O(n)
平均 最坏O(n^2)
数据有序
数据逆序
📑性能分析
稳定性：稳定
插入排序，初始数据越接近有序，时间效率越高。
📑折半插入排序
在有序区间选择数据应该插入的位置时，因为区间的有序性，可以利用折半查找的思想。
public static void bsInsertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
int v = array[i];
int left = 0;
int right = i;
// [left, right)
// 需要考虑稳定性
while (left < right) {
int m = (left + right) / 2;
if (v >= array[m]) {
left = m + 1;
} else {
right = m;
}
}
// 搬移
for (int j = i; j > left; j--) {
array[j] = array[j - 1];
}
📑希尔排序
📑原理
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有
距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达 =1 时，
所有记录在统一组内排好序。
- 希尔排序是对直接插入排序的优化。
- 当 gap > 1 时都是预排序，目的是让数组更接近于有序。当 gap == 1 时，数组已经接近有序的了，这样就会很
快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
array [ left ] = v ;
时间复杂度
空间复杂度
最好O(n)
平均O(n^1.3)
最坏O(n^2)
数据有序
比较难构造
📑性能分析
稳定性：不稳定
📑选择排序
📑**直接选择排序-**原理
public static void shellSort(int[] array) {
int gap = array.length;
while (gap > 1) {
insertSortGap(array, gap);
gap = (gap / 3) + 1; // OR gap = gap / 2;
}
insertSortGap(array, 1);
}
private static void insertSortGap(int[] array, int gap) {
for (int i = 1; i < array.length; i++) {
int v = array[i];
int j = i - gap;
for (; j >= 0 && array[j] > v; j -= gap) {
array[j + gap] = array[j];
}
array[j + gap] = v;
}
}
时间复杂度
空间复杂度
O(n^2)
O(1)
数据不敏感
数据不敏感
每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素
排完 。
public static void selectSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
// 无序区间: [0, array.length - i)
// 有序区间: [array.length - i, array.length)
int max = 0;
for (int j = 1; j < array.length - i; j++) {
if (array[j] > array[max]) {
max = j;
}
}
int t = array[max];
array[max] = array[array.length - i - 1];
array[array.length - i - 1] = t;
}
}
int[] a = { 9, 2, 5a, 7, 4, 3, 6, 5b };
// 交换中该情况无法识别，保证 5a 还在 5b 前边
public static void selectSortOP(int[] array) {
📑性能分析
稳定性：不稳定
📑双向选择排序
每一次从无序区间选出最小 + 最大的元素，存放在无序区间的最前和最后，直到全部待排序的数据元素排完 。
📑堆排序
📑原理
基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的
数。
注意： 排升序要建大堆；排降序要建小堆。
int low = 0;
int high = array.length - 1;
// [low, high] 表示整个无序区间
// 无序区间内只有一个数也可以停止排序了
while (low <= high) {
int min = low;
int max = low;
for (int i = low + 1; i <= max; i++) {
if (array[i] < array[min]) {
min = i;
}
if (array[i] > array[max]) {
max = i;
}
}
swap(array, min, low);
// 见下面例子讲解
if (max == low) {
max = min;
}
swap(array, max, high);
}
}
private void swap(int[] array, int i, int j) {
int t = array[i];
array[i] = array[j];
array[j] = t;
}
array = { 9, 5, 2, 7, 3, 6, 8 }; // 交换之前
// low = 0; high = 6
// max = 0; min = 2
array = { 2, 5, 9, 7, 3, 6, 8 }; // 将最小的交换到无序区间的最开始后
// max = 0，但实际上最大的数已经不在 0 位置，而是被交换到 min 即 2 位置了
// 所以需要让 max = min 即 max = 2
array = { 2, 5, 8, 7, 3, 6, 9 }; // 将最大的交换到无序区间的最结尾后
📑实现
public static void heapSort(int[] array) {
createHeap(array);
for (int i = 0; i < array.length - 1; i++) {
// 交换前
// 无序区间: [0, array.length - i)
// 有序区间: [array.length - i, array.length)
swap(array, 0, array.length - i - 1);
// 交换后
// 无序区间: [0, array.length - i - 1)
// 有序区间: [array.length - i - 1, array.length)
// 无序区间长度: array.length - i - 1
shiftDown(array, array.length - i - 1, 0);
}
}