七大排序整理（选择排序/直接插入排序/shell（希尔)排序/冒泡排序/快速排序/堆排/归并排序）

• 选择排序 ：请看后文
• 直接插入排序 : 请看后文
• shell排序 : 请看后文
• 冒泡排序 : 请看后文
• 快速排序 快速排序请点此链接
• 堆排 堆排请点此链接
• 归并排序 归并排序请点此链接

各种排序性能对比如下:

排序类型	平均情况	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
选择排序	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;
        }
    }
}