一篇解决常用排序算法 附JAVA代码

参考：https://mp.weixin.qq.com/s/teOGQlslb6aP4AQrx7TTzA

以下例子都默认升序。
以下每种排序都是最简单的实现，没有写优化。
稳定的意思：相同值的两元素的相对顺序，在排序前后不发生改变。

1.O(n²)的排序算法

1.1 冒泡排序

概括：在每一轮[0…length-1]中，元素两两比较，使这一轮最大的数冒到这一轮的最后一个位置[length-1-i]。
稳定性:稳定
时间复杂度:外层循环length次，内层循环length-i-1次，总的时间复杂度为O(n²)
空间复杂度：O(1)

    //冒泡排序
    public static void sort(int[] nums){
        for(int i=0;i<nums.length;i++){
            for(int j=0;j<nums.length-1-i;j++){
                if(nums[j+1]<nums[j]){
                    int tmp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=tmp;
                }
            }
        }
    }

1.2 选择排序

概括：每一次(i∈[0,length-2])都找到最小的元素(j∈[i+1,length-1])，放到这一轮的最前面(i)
稳定性 ：不稳定
时间复杂度：O(n²)
空间复杂度：O(1)

    private static void sort(int[] nums) {
        for(int i=0;i<nums.length;i++){
            int min=i;//最小值的下标
            for(int j=i+1;j<nums.length;j++){
                if(nums[j]<nums[min]){
                    min=j;
                }
            }
            int tmp=nums[i];
            nums[i]=nums[min];
            nums[min]=tmp;
        }
    }

1.3 插入排序

概括：每次将新的元素(i∈[1…length-1])插入已经有序的序列[0,i-1]中，选择合适的位置。
稳定性：稳定
时间复杂度: O(n²)
空间复杂度：O(1)

    private static void sort(int[] nums) {
        int j;
        for(int i=1;i<nums.length;i++){
            int tmp=nums[i];
            for(j=i-1;j>=0&&nums[j]>tmp;j--){
                nums[j+1]=nums[j];
            }
            nums[j+1]=tmp;
        }
    }

2.O(logn)的排序算法

2.1 希尔排序

概括：是插入排序的升级版。每次取跨度为d[1…length/2]，对每一组进行插入排序。
稳定性：不稳定
时间复杂度：平均时间复杂度O(n·log2n)。极端情况下是O(n²)。
空间复杂度：O(1)
过程：
此处分组跨度（4，2，1），被称为希尔排序的增量，是逐步折半的增量方法。

    private static void sort(int[] nums) {
        int d=nums.length;
        while(d>1){
            d=d/2;
            int j;
            for(int x=0;x<d;x++){
                for(int i=x+d;i<nums.length;i=i+d){
                    int tmp=nums[i];
                    for(j=i-d;j>=0&&nums[j]>tmp;j=j-d){
                        nums[j+d]=nums[j];
                    }
                    nums[j+d]=tmp;
                }
            }
        }
    }

2.2 快速排序

概括：每一轮挑选一个基准元素（比如第一个元素），并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成两个部分。左半部分也这么做，右半部分也这么做。
稳定性：不稳定
时间复杂度：平均情况下需要logn轮，所以平均时间复杂度是O（nlogn），但是在极端情况下，最坏时间复杂度是O（n^2）。
空间复杂度：递归和非递归都是O(n）
快速排序

/*指针交换法*/
    public static void sort(int[] nums, int i, int j) {
        if (i >= j)
            return;
        int k = partition(nums, i, j);
        sort(nums, i, k - 1);
        sort(nums, k + 1, j);
    }
    public static int partition(int[] nums,int left,int right){
        int i=left;
        int j=right;
        int v=nums[left];
        while(i<j){
            while(i<j&&nums[j]>=v)
                j--;
            while(i<j&&nums[i]<=v)
                i++;
            if(i>=j)
                break;
            int t=nums[i];
            nums[i]=nums[j];
            nums[j]=t;
        }
        nums[left]=nums[i];
        nums[i]=v;
        return i;
    }
}

    private static void sort(int[] nums,int left,int right) {
        if(left>=right)
            return;
        int index=partition(nums,left,right);
        sort(nums,left,index-1);
        sort(nums,index+1,right);
    }
    private static int partition(int[] nums,int left,int right){
        int a=nums[left];
        int index=left;
        while(left<=right){
            while(left<=right){
                if(nums[right]<a){
                    nums[left]=nums[right];
                    index=right;
                    left++;
                    break;
                }
                right--;
            }

            while(left<=right){
                if(nums[left]>a){
                    index=left;
                    nums[right]=nums[left];
                    right--;
                    break;
                }
                left++;
            }
        }
        nums[index]=a;
        return index;
    }

2.3 归并排序

概括：对集合分组直到不能分（元素个数为1）为止，合并两两分组。
稳定性：稳定
时间复杂度：O(nlogn)。有logn层，每一层的运算量是O(n)，所以是O(nlogn)。
空间复杂度：O(n)。因为每次归并所创建的集合都会因为方法结束而释放。因此这部分空间不应该累加计算。

2.4 堆排序

代码：https://blog.csdn.net/weixin_42970433/article/details/109799424
稳定性:不稳定
时间复杂度：
二叉堆的下沉调整的最坏时间复杂度就等于二叉树的高度O(logn)。
第一步，把无序数组构建成二叉堆，需要n/2次循环。每次循环调用一次downAdjust方法，所以第一步的计算规模是n/2*logn，时间复杂度O(nlogn)。
第二步，需要进行n-1次循环，每次循环调用一次downAjust方法，计算规模是(n-1)*logn
所以总时间复杂度是O(nlogn)。
空间复杂度：O(1)

import java.util.Arrays;

public class HeapSort {
    /*
    得到升序，要先构造大顶堆。
    我们每一次删除旧堆顶，调整后的新堆顶都是大小仅次于旧堆顶的节点。
    那么我们只要反复删除堆顶，反复调节二叉堆，所得到的集合就成为了一个有序集合。
     */
    public static void main(String[] args) {
        //堆排序
        int[] array2=new int[]{7,1,3,10,5,2,8,9,6};
        heapSort(array2);
        System.out.println(Arrays.toString(array2));
    }
    public static void heapSort(int[] array){
        //从最后一个非叶子节点开始，依次下沉调整
        for(int i=(array.length-2)/2;i>=0;i--){
            downAdjust(array,i,array.length);
        }
        //现在是个大顶堆了
        System.out.println(Arrays.toString(array));
        //循环删除堆顶元素，移到集合尾部，调节堆产生新的堆顶。
        for(int i=array.length-1;i>0;i--){
            int temp=array[i];
            array[i]=array[0];
            array[0]=temp;
            downAdjust(array,0,i);
        }
    }

    //下沉调整
    /*
    构建二叉堆，也就是把一个无序的完全二叉树调整为二叉堆，本质上就是让所有非叶子节点依次下沉。
     */
    private static void downAdjust(int[] array, int parentIndex, int length) {
        //array:要调整的堆，parentIndex：要下沉的父节点，length:堆的有效大小
        int temp=array[parentIndex];
        int childIndex=2*parentIndex+1;
        while(childIndex<length){
            //如果有右孩子，且右孩子大于左孩子,则定位到右孩子
            if(childIndex+1<length&&array[childIndex+1]>array[childIndex]){
                childIndex++;
            }
            //父节点大于任意一个孩子的值，跳出循环
            if(temp>=array[childIndex]){
                break;
            }
            array[parentIndex]=array[childIndex];
            parentIndex=childIndex;
            childIndex=childIndex*2+1;
        }
        array[parentIndex]=temp;
    }
}

3.线性时间复杂度的排序算法

3.1 计数排序

概括：
朴素：在最大值和最小值之间建立数组，统计每个数a出现的次数，存放在数组中下标为a的位置。
优化：统计数组从第二个元素开始，每一个元素都加上前面所有元素之和。让统计数组存储的元素值，等于相应整数的最终排序位置。
缺点：
1.当数列最大最小值差距过大时，并不适用计数排序。
比如给定20个随机整数，范围在0到1亿之间，这时候如果使用计数排序，需要创建长度1亿的数组。不但严重浪费空间，而且时间复杂度也随之升高。
2.当数列元素不是整数，并不适用计数排序。
如果数列中的元素都是小数，比如25.213，或是0.00000001这样子，则无法创建对应的统计数组。这样显然无法进行计数排序。
稳定性：优化版的计数排序是稳定的。

3.1.1 朴素的计数排序

3.1.2 优化的计数排序

时间复杂度：遍历原始序列3次，3N。遍历统计序列一次，M。总运算量3N+M。
去掉系数，时间复杂度是O(N+M).
空间复杂度：统计数组O(M)

    private static int[] sort(int[] nums) {
        int len=nums.length;
        //寻找最大最小值
        int max=Integer.MIN_VALUE,min=Integer.MAX_VALUE;
        for(int a=0;a<len;a++){
            if(nums[a]<min)
                min=nums[a];
            if(nums[a]>max)
                max=nums[a];
        }
        //统计数组
        int[] tmp=new int[max-min+1];
        for(int b=0;b<len;b++){
            tmp[nums[b]-min]++;
        }
        //统计数组做变形，后面的元素等于前面的元素之和
        int sum=0;
        for(int e=0;e<max-min+1;e++){
            sum+=tmp[e];
            tmp[e]=sum;
        }
        //倒序遍历原始数列，从统计数组找到正确位置，输出到
        // 结果数组
        int[] res=new int[len];
        for(int c=len-1;c>=0;c--){
            res[tmp[nums[c]-min]-1]=nums[c];
            tmp[nums[c]-min]--;
        }
        return res;
        /*
        朴素
        for(int c=0;c<max-min+1;c++){
            for(int d=0;d<tmp[c];d++){
                System.out.println((c+min)+",");
            }
        }
         */
    }

3.2 桶排序

步骤

1.创建桶。桶的个数=元素个数。区间跨度=（最大值-最小值）/（桶的个数-1）
2.遍历序列。将元素加入对应的桶。
3.每个桶内部分别排序。
4.遍历桶。输出元素。
时间复杂度：

桶排序性能不稳定。桶中元素分布均匀时，最好情况时间复杂度为O(N)。如果桶内元素分布极不均衡，退化到O(nlogn)。
空间复杂度：

    private static void sort(double[] nums) {
        int len=nums.length;
        int m=len;//桶的个数
        //寻找最大最小值
        double min=Double.MAX_VALUE;
        double max=Double.MIN_VALUE;
        for(int i=0;i<len;i++){
            if(nums[i]<min)
                min=nums[i];
            if(nums[i]>max)
                max=nums[i];
        }
        double d=max-min;

        //初始化桶
        ArrayList<LinkedList<Double>> list=new ArrayList<>(len);
        for(int i=0;i<len;i++){
            list.add(new LinkedList<Double>());
        }
        //将元素加入桶
        for(int i=0;i<len;i++){
            //(nums[i]-min)*(len-1)/d
            list.get((int)((nums[i]-min)*(len-1)/d)).add(nums[i]);
        }
        //对每个桶内部进行排序
        for(int i=0;i<len;i++){
            //JDK底层采用了归并排序或归并的优化版本
            Collections.sort(list.get(i));
        }
        //输出
        for(int i=0;i<len;i++){
            for(int j=0;j<list.get(i).size();j++){
                System.out.println(list.get(i).removeFirst());
            }
        }
    }
}

3.3 基数排序

为什么需要基数排序：
计数排序适合的场景是对整数做排序。如何有效处理诸如手机号、英文单词等复杂元素的排序呢？仅仅靠一次计数排序很难实现。
概括：
把排序工作拆分成多个阶段，每一个阶段只根据一个字符进行计数排序（这里的计数排序必须是稳定排序），一共排序k轮（k是元素长度）。
基数排序既可以从高位优先进行排序（Most Significant Digit first，简称MSD），也可以从低位优先进行排序（Least Significant Digit first，简称LSD）。
对于字符串长度不等的情况，以最长的字符串为准，在其他长度不足的字符串末尾补0.

时间复杂度：计数排序的时间复杂度是O(M+N).而基数排序进行了K次计数排序，所以时间复杂度是O(K*(M+N))。由于字符串长度K是一个固定常量，所以我们仍然认为它是一个线性排序算法。
空间复杂度：由于基数排序的数组是反复重用的，所以基数排序的空间复杂度和计数排序一样，是O(M+N).其中M是字符的取值范围大小。

import java.util.Arrays;

public class 基数 {
    public static final int ASCII_RANGE=128;
    public static void main(String[] args) {
        String[] array={"qd","abc","qwe","hhh","a","cws","ope"};
        System.out.println(Arrays.toString(radixSort(array,3)));
    }

    private static String[] radixSort(String[] array, int maxLength) {
    	//排序结果数组，用于存储每一次按位排序的临时结果
        String[] sortedArray=new String[array.length];
        //从个位开始比较，一直比较到最高位
        for(int k=maxLength-1;k>=0;k--){
            int[] count=new int[ASCII_RANGE];
            //计数排序的过程，分成三步：
			//1.创建辅助排序的统计数组，并把待排序的字符对号入座，
        	//这里为了代码简洁，直接使用ascii码范围作为数组长度
            for(int i=0;i<array.length;i++){
                int index=getCharIndex(array[i],k);
                count[index]++;
            }
            //2.统计数组做变形，后面的元素等于前面的元素之和
            for(int i=1;i<count.length;i++){
                count[i]=count[i]+count[i-1];
            }
            //3.倒序遍历原始数列，从统计数组找到正确位置，输出到结果数组
            for(int i=array.length-1;i>=0;i--){
                int index=getCharIndex(array[i],k);
                int sortedIndex=count[index]-1;
                sortedArray[sortedIndex]=array[i];
                count[index]--;
            }
            //下一轮排序需要以上一轮的排序结果为基础，因此把结果复制给array
            array=sortedArray.clone();
        }
        return array;
    }
	//获取字符串第k位字符所对应的ascii码序号
    private static int getCharIndex(String str,int k){
    	//如果字符串长度小于k，直接返回0，相当于给不存在的位置补0
        if(str.length()-1<k){
            return 0;
        }
        return str.charAt(k);
    }
}