十大排序算法总结及其代码实现

1、算法分类

2、时间复杂度分析

3、基本的排序算法

3.1、冒泡排序

public class BubbleSort1 {
    public static void main(String[]args){
        int array[]={5,4,2,6,8,1};
        System.out.println("排序前的数组数字排列顺序为：");
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+"\t");
        }
        System.out.println();
        bubblesort(array);
        System.out.println("排序后的数组数字排列顺序为：");
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+"\t");
        }
    }
    private static void bubblesort(int[] array) {
        if(array==null||array.length==0){
            return ;
        }
        //冒泡排序每次循环是将最大的数放置在后端
        for(int i=0;i<array.length-1;i++){
            for(int j=0;j<array.length-i-1;j++){
                if(array[j]>array[j+1]){//如果前面的大于后面的就交换
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
    }
}

3.2、插入排序

    private static void insertsort(int[] array) {
        if(array==null||array.length==0){
            return ;
        }
        for(int i=1;i<array.length;i++){
            for(int j=i;j>0;j--){
                //运用内部两两交换机制
                if(array[j]<array[j-1]){
                    int temp=array[j-1];
                    array[j-1]=array[j];
                    array[j]=temp;
                }
            }
        }
    }

采用内部索引移动策略：

private static void insertsort(int[] array) {
        if(array==null||array.length==0){
            return ;
        }
        for(int i=1;i<array.length;i++){
            int j=i;//j记录即将要排序的数的位置即目标数的原位置
            int target=array[j];
            while(j>0&&target<array[j-1]){
                array[j]=array[j-1];
                j--;
            }
            array[j]=target;
        }
    }

3.3、选择排序

    private static void selectsort(int[] array) {
        for(int i=0;i<array.length-1;i++){
            int index=i;//记录该次循环的最小数字index
            for(int j=i+1;j<array.length;j++){
                //每比较一次都需要将较小的数的下标记录下来
                if(array[index]>array[j]){
                    index=j;
                }
            }
            //一次循环中遇到比该数字更小的数字，就交换
            if(index!=i){
                int temp=array[index];
                array[index]=array[i];
                array[i]=temp;
            }
            System.out.println("第"+(i+1)+"次结果是"+ Arrays.toString(array));
        }
    }

4、基础改进后的排序算法

4.1、希尔排序

就是在插入排序的基础上，并不是每次只相邻比较，而是设置一个比较的增量元素。

    private static void shellsort(int[] array) {
        if(array==null||array.length==0){
            return ;
        }
        int k=array.length/2;
        while(k>0){
            for(int i=k;i<array.length;i++){
                int j=i;//j记录即将要排序的数的位置即目标数的原位置
                int target=array[i];
                while(j>=k&&target<array[j-k]){
                    array[j]=array[j-k];
                    j-=k;
                }
                array[j]=target;
            }
            System.out.println("增量为"+k+"排序之后"+ Arrays.toString(array));
            k/=2;
        }
    }

4.2、快速排序

    private static void quicksort(int[] array, int start, int end) {
        if(start<end){
            int temp=qSort(array,start,end);
            quicksort(array,start,temp-1);
            quicksort(array,temp+1,end);
        }
    }

    /**
     *
     * @param array 待排序的数组
     * @param left 待排序数组的最小下标
     * @param right 待排序数组的最大下标
     * @return 排序后基准数的位置下标，方便下次的分区
     */
    private static int qSort(int[] array, int left, int right) {
        int temp=array[left];
        while(left<right){//循环执行的条件
            while(left<right && array[right]>=temp){//说明右边的数字大于基准数字
                right--;//右指针左移一位
            }
            if(left<right){//说明右边的数字小于基准数字
                array[left++]=array[right];
            }
            while(left<right && array[left]<=temp){//说明左边的数字小于基准数字
                left++;//左指针左移一位
            }
            if(left<right){//说明右边的数字小于基准数字
                array[right--]=array[left];
            }
        }
        //当循环结束说明左指针和右指针已经相遇。并且相遇的位置是一个空出的位置,
        //这时候将基准数填入该位置，并返回该位置的下标，为分区做准备。
        array[left]=temp;
        return left;
    }

4.3、堆排序

    private static void heapsort(int[] array) {
        if(array==null||array.length<2){
            return ;
        }
        //构造初始堆,从第一个非叶子节点开始调整,左右孩子节点中较大的交换到父节点中
        for(int i=array.length/2-1;i>=0;i--){
            adjustHeap(array,i,array.length);
        }
        //排序，将最大的节点放在堆尾，然后从根节点重新调整
        for(int i=array.length-1;i>0;i--){
            swap(array,0,i);
            adjustHeap(array,0,i);
        }
    }

    /**
     * 
     * @param array 数组
     * @param i 元素1
     * @param j 元素2
     */
    private static void swap(int[] array, int i, int j) {
        int temp=array[i];
        array[i]=array[j];
        array[j]=temp;
    }

    /**
     * 整理树让其变成堆
     * @param arr 待整理的数组
     * @param i 开始的结点
     * @param j 数组的长度
     */
    public static void adjustHeap(int[] arr,int i,int j) {
        int temp=arr[i];//定义一个变量保存开始的结点
        //k就是该结点的左子结点下标
        for(int k=2*i+1;k<j;k=2*k+1) {
            //比较左右两个子结点的大小，k始终记录两者中较大值的下标
            if(k+1<j && arr[k]<arr[k+1]) {
                k++;
            }
            //经子结点中的较大值和当前的结点比较，比较结果的较大值放在当前结点位置
            if(arr[k]>temp) {
                arr[i]=arr[k];
                i=k;
            }else{//说明已经是大顶堆
                break;
            }
        }
        arr[i]=temp;
    }

4.4、归并排序

private static void mergesort(int[] array, int left, int right) {
        int mid=(left+right)/2;
        if(left<right){
            mergesort(array,left,mid);
            mergesort(array,mid+1,right);
            combine(array,left,mid,right);
        }
    }

    private static void combine(int[] array, int left, int mid, int right) {
        int []temp=new int [right-left+1];//设置一个临时数组存放结果
        int i=left;//左边指针
        int j=mid+1;//右边指针
        int k=0;
        while(i<=mid&&j<=right){
            if(array[i]<=array[j]){
                temp[k++]=array[i++];
            }else{
                temp[k++]=array[j++];
            }
        }
        while(i<=mid){
            temp[k++]=array[i++];
        }
        while(j<=right){
            temp[k++]=array[j++];
        }
        for(int l=0;l<temp.length;l++){
            array[l+left]=temp[l];
        }
    }

4.5、计数排序

   private static void countsort(int[] array) {
        if(array==null||array.length==0){
            return ;
        }
        int maxNum=array[0];
        int minNum=array[0];
        //找出最大值和最小值
        for(int i=1;i<array.length;i++){
            maxNum=maxNum>array[i]?maxNum:array[i];
            minNum=minNum<array[i]?minNum:array[i];
        }
        //创建一个临时数组
        int [] temp=new int [maxNum+1];
        for(int i=0;i<array.length;i++){
            temp[array[i]]++;
        }
        //将临时数组的数字放到排序后的数组中去
        int k=0;
        for(int i=minNum;i<temp.length;i++){
            while(temp[i]>0){
                array[k++]=i;
                temp[i]--;
            }
        }
    }

4.6、基数排序

    private static void redixsort(int[] array,int redix,int d) {
        // 缓存数组
        int[] tmp = new int[array.length];
        // buckets用于记录待排序元素的信息
        // buckets数组定义了max-min个桶
        int[] buckets = new int[redix];

        for (int i = 0, rate = 1; i < d; i++) {

            // 重置count数组，开始统计下一个关键字
            Arrays.fill(buckets, 0);
            // 将data中的元素完全复制到tmp数组中
            System.arraycopy(array, 0, tmp, 0, array.length);

            // 计算每个待排序数据的子关键字
            for (int j = 0; j < array.length; j++) {
                int subKey = (tmp[j] / rate) % redix;
                buckets[subKey]++;
            }

            for (int j = 1; j < redix; j++) {
                buckets[j] = buckets[j] + buckets[j - 1];
            }

            // 按子关键字对指定的数据进行排序
            for (int m = array.length - 1; m >= 0; m--) {
                int subKey = (tmp[m] / rate) % redix;
                array[--buckets[subKey]] = tmp[m];
            }
            rate *= redix;
        }
    }

4.7、桶排序

桶排序是计数排序的升级版，利用了函数的映射关系，高效与否的关键在于这个映射函数的确定，桶排序的工作原理就是假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或者以递归的方式继续使用桶排序进行排序）。

总结：

一、稳定性:

稳定：冒泡排序、插入排序、归并排序和基数排序

不稳定：选择排序、快速排序、希尔排序、堆排序

二、平均时间复杂度

O(n^2):直接插入排序，简单选择排序，冒泡排序。

在数据规模较小时（9W内），直接插入排序，简单选择排序差不多。当数据较大时，冒泡排序算法的时间代价最高。性能为O(n^2)的算法基本上是相邻元素进行比较，基本上都是稳定的。

O(nlogn):快速排序，归并排序，希尔排序，堆排序。

其中，快排是最好的， 其次是归并和希尔，堆排序在数据量很大时效果明显。

三、排序算法的选择

1.数据规模较小

（1）待排序列基本序的情况下，可以选择直接插入排序；

（2）对稳定性不作要求宜用简单选择排序，对稳定性有要求宜用插入或冒泡

2.数据规模不是很大

（1）完全可以用内存空间，序列杂乱无序，对稳定性没有要求，快速排序，此时要付出log（N）的额外空间。

（2）序列本身可能有序，对稳定性有要求，空间允许下，宜用归并排序

3.数据规模很大

（1）对稳定性有求，则可考虑归并排序。

　　（2）对稳定性没要求，宜用堆排序

4.序列初始基本有序（正序），宜用直接插入，冒泡