各种排序性能对比如下:
| 排序类型 | 平均情况 | 最好时间复杂度 | 最坏时间复杂度 | 空间复杂度 | 稳定性 |
|---|---|---|---|---|---|
| 选择排序 | O(n²) | O(n²) | O(n²) | O(1) | 不稳定 |
| 冒泡排序 | O(n²) | O(n) | O(n²) | O(1) | 稳定 |
| 直接插入 | O(n²) | O(n) | O(n²) | O(1) | 稳定 |
| 希尔排序 | O(n^1.3) | O(nlogn) | O(n²) | O(1) | 不稳定 |
| 归并排序 | O(nlog₂n) | O(nlog₂n) | O(nlog₂n) | O(n) | 稳定 |
| 快速排序 | O(nlog₂n) | O(nlog₂n) | O(n²) | O(nlog₂n) | 不稳定 |
| 堆排序 | O(nlog₂n) | O(nlog₂n) | O(nlog₂n) | O(1) | 不稳定 |
一. 选择排序：时间复杂度(O(n2)),不稳定，空间复杂度 O(1)
思想：每次该元素与其后面所剩的元素注意比较，将小的元素与该元素交换值
即：双重循环，外循环i从0下表开始，内循环j从i+1开始，比较array[i]与array[j]的值，将小的值替换到array[i]。
public class SelectSort {
public static void main(String[] args) {
int[] array={2,4,78,20,55,
92,83,5,40,10,
72,25,10,0,1};
selectsort(array);
System.out.println(Arrays.toString(array));
}
public static void selectsort(int[] array){
for (int i = 0; i <array.length-1 ; i++) {
for (int j = i+1; j <array.length ; j++) {
if (array[i]>array[j]){
int tmp=array[j];
array[j]=array[i];
array[i]=tmp;
}
}
}
}
}
二. 冒泡排序 （最好）有序 O(n), 无序 O(n2), 空间O(1)，稳定
思想：从数组的第一个元素开始，如果后一个元素比当前元素小，那么当前
元素往后走，一直重复的遍历这个数组
即：双重循环，外循环i从0到array.length-1；内循环j从0到array.length-1-i；比较array[j]和array[j+1]；
每趟都将前（array.length-1-i）中最大的值放到前（array.length-1-i）的最后；
下面数据 以前两趟为例：
public class MaoPaoSort {
public static void main(String[] args) {
int[] array={2,4,78,20,55,
92,83,5,40,10,
72,25,10,0,1};
bubbleSort(array);
System.out.println(Arrays.toString(array));
}
public static void bubbleSort(int[] array){
for (int i = 0; i <array.length-1 ; i++) {
for (int j = 0; j <array.length-1-i ; j++) {
if (array[j]>array[j+1]){
int tmp=array[j];
array[j]=array[j+1];
array[j+1]=tmp;
}
}
}
}
}
三. 直接插入排序 时间：有序 O(n),无序 O(n2), 空间：O(1)稳定
思想：如同打扑克牌一样，从第二个元素开始，然后每次去和前面的比较，如果该元素大于前面的则就放入该位置，否则继续往前走，并且走过的位置都要后移，直到找到比他大的元素，如果到0号元素还没有找到， 则放入0号元素位置
public class InsertSort {
public static void main(String[] args) {
int[] array={2,4,78,20,55,
92,83,5,40,10,
72,25,10,0,1};
insert(array);
System.out.println(Arrays.toString(array));
}
public static void insert(int[] array){
for (int i = 1; i < array.length; i++) {
int tmp=array[i];
int j=0;
for ( j = i-1; j >=0 ; j--) {
if (array[j]>tmp){
array[j+1]=array[j];
}else break;
}
array[j+1]=tmp;
}
}
}
四.shell（希尔）排序
时间：最好O(nlogn)，最坏：O(n²) 空间: O(1) 不稳定
思想：，主要还是利用直接插入排序+采用分组的思想，
把一组数字分为若干的小组，而在分组的过程当中，并不是几个几个紧挨着的分组，而是采用特定的分组方式，每一次都让组内有序，这样排序的好处是，每次排序都是将小的数据尽量往前赶，大的数据尽量往后赶。在这里面，每一组的数字个数，在每一次分组的时候，都会缩小增量，比如第一次分组每组 3 个，第二次每组 5 个，第三次每组 1 个这样去分。（最后一次就直接进行一次插入排序，优点在于，如果不执行前面的分组过程的话，数据的
移动次数更多，更复杂，经过排序之后，数据已经越来越有序了。 利用直接插入排序特性 ）
public class Shell {
public static void main(String[] args) {
int[] array={2,4,78,20,55,
92,83,5,40,10,
72,25,10,0,1};
sheellSort(array);
System.out.println(Arrays.toString(array));
}
public static void sheellSort(int[] array){
int[] brray={5,3,1};
for (int i = 0; i <3 ; i++) {
shell(array,brray[i]);
}
}
public static void shell(int[] array,int gmp){
for (int i = gmp; i <array.length ; i++) {
int tmp=array[i];
int j=0;
for (j = i-gmp; j >=0 ; j-=gmp) {
if (array[j]>tmp){
array[j+gmp]=array[j];
}else break;
}
array[j+gmp]=tmp;
}
}
}