- List item
1.直接插入排序(稳定)
视频演示:直接插入排序
思路:每次选择无序区间的第一个元素,在有序区间内选择合适的位置插入(类似于搬运)。
public class Sort {
// 直接插入排序 (升序)
public static void insertSort(int[] array) {
for (int i = 1; i < array.length; i++) { //循环n-1次
// 有序 [0, i) 假设第一个数有序
// 无序 [i, array.length) 其余数无序
int key = array[i]; //无序区间第一个数
int j;
for (j = i - 1; j >= 0; j--) { //在有序区间从后向前比较
if (array[j] <= key) {
break;
} else {
array[j + 1] = array[j]; //数据后移
}
}
array[j + 1] = key; //插入key 排列完成
}
}
//程序优化
public static void insertSort0(int[] array) {
for (int i = 1; i < array.length; i++) {
// 有序 [0, i)
// 无序 [i, array.length)
int key = array[i];
int j;
for (j = i - 1; j >= 0 && array[j] > key; j--) {
array[j + 1] = array[j];
}
array[j + 1] = key;
}
}
/**
* 时间复杂度
* 最好 平均 最坏
* O(n) O(n^2) O(n^2)
* 数据有序 数据逆序
* 空间复杂度
* O(1)
*/
public static void main(String[] args) {
int[] a = { 2, 3, 7, 9, 4, 5, 6, 9, 1, 4, 7, 8 };
int[] b = a.clone(); //clone()方法是用来复制数组
insertSort(b);
System.out.println(Arrays.toString(b));
int[] c = a.clone();
Arrays.sort(c); //直接调包 系统排序
System.out.println(Arrays.toString(c));
System.out.println(Arrays.equals(b, c)); //数组是否相等 调用Arrays.equals(b, c)
}
}
注意
1)在有序区间从后向前判断。假设其实数据已经是升序,直接比较有序区间最后一个数,若key比有序区间最后一个数大,则不用插入;若从前向后判断,则最好情况不存在。
2)性能分析:
3)稳定。
4)插入排序元素个数少时或者元素基本有序时效率比较高。
2.希尔排序(不稳定)
视频演示:希尔排序
思路:分组插入排序
1)希尔排序是对直接插入排序的优化。
2)当gap > 1时都是预排序,目的是让数组更接近于有序。当gap == 1时,数组已经接近有序的了,这样就会很快。
public class Sort {
//希尔排序 (升序)
public static void shellSort(int[] array) {
int gap = array.length;
while (true) {
gap = (gap / 3) + 1; //无论如何分组一定保证最终gap==1
//gap = gap / 2;
insertSortWithGap(array, gap);
if (gap == 1) {
break; //排序结束gap==1 则排序结束
}
}
}
private static void insertSortWithGap(int[] array, int gap) {
for (int i = gap; i < array.length; i++) { //假设第一组有序
int key = array[i];
int j;
for (j = i - gap; j >= 0 && array[j] > key; j -= gap) {
array[j + gap] = array[j];
}
array[j + gap] = key;
}
}
}
注意
1)gap最终一定要可以缩减为1。
2)不稳定。
3)性能分析:
3.直接选择排序(不稳定)
图片演示:选择排序
思路:每一次从无序区间选出最大(或最小)的一个元素,存放在无序区间的最后(或最前),直到全部待排序的数据元素排完(类似于打擂台的方式)。
//直接选择排序 (升序)
public static void selectSort(int[] array) {
// 每次选最大的放到无序区间的最后
for (int i = 0; i < array.length - 1; i++) { //循环n-1次
// 无序 [0, array.length - i)
// 有序 [array.length - i, array.length)
int maxIndex = 0; //假设最大数下标0
for (int j = 1; j < array.length - i; j++) { //从下标为1的数开始比较
if (array[j] > array[maxIndex]) {
maxIndex = j; //maxIndex记录真正最大数的下标
}
}
swap(array, maxIndex, array.length - i - 1); //放到无序区间最后
}
}
//直接选择排序 (降序)
public static void selectSort0(int[] array) {
// 每次选最小的放到无序区间的最开始
for (int i = 0; i < array.length - 1; i++) {
// 无序区间 [i, array.length)
int minIndex = i;
for (int j = i + 1; j < array.length; j++) {
if (array[j] < array[minIndex]) {
minIndex = j;
}
}
swap(array, minIndex, i);
}
}
private static void swap(int[] array, int i, int j) {
int t = array[i];
array[i] = array[j];
array[j] = t;
}
注意
1)直接选择排序是数据不敏感型排序 ——原始数据顺序对选择排序顺序没有影响。
2)不稳定
3)性能分析:
双向选择排序
思路:每一次从无序区间选出最小 + 最大的元素,存放在无序区间的最前和最后,直到全部待排序的数据元素排完 。
//双向选择排序
public static void selectSort2(int[] array) {
// 无序: [begin, end]
int begin = 0;
int end = array.length - 1;
while (begin < end) { //长度小于等于1就可以停止
int minIndex = begin;
int maxIndex = begin;
for (int j = begin + 1; j <= end; j++) {
if (array[j] < array[minIndex]) {
minIndex = j;
}
if (array[j] > array[maxIndex]) {
maxIndex = j;
}
}
swap(array, minIndex, begin);
//最大数刚好就在begin位置 需特殊处理
if (maxIndex == begin) { //最大数下标发生变化
maxIndex = minIndex;
}
swap(array, maxIndex, end);
begin++; end--;
}
}
private static 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 }; // 将最大的交换到无序区间的最结尾后