十大排序算法

https://www.cxyxiaowu.com/2026.html、
https://www.cxyxiaowu.com/725.html

1、冒泡排序

从序列的一端往另一端冒泡，依次比较相邻的两个数的大小。

public int[] sortMP(int[] arr) {
        for(int i = arr.length-1;i > 0;i--) {
            boolean isSort = true;
            for(int j = arr.length-1;j > arr.length-i-1;j--) {
                int temp;
                if(arr[j] < arr[j-1]) {
                    temp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                    isSort = false;
                }
            }
            if(isSort) {
                break;
            }
        }
        return arr;
    }

时间复杂度：O(n^2)

2、选择排序

在未排序序列中找到最小(大)元素，存放到的已排序序列的起始位置；再从剩下的未排序序列中继续找到最小(大)元素，放到已排序序列的末尾。重复操作直至所有元素均已排序完毕。

    public int[] sortXZ(int[] arr) {
        for(int i = 0;i<arr.length-1;i++) {
            int minIndex = i;
            for(int j = i+1;j<arr.length;j++) {
                if(arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        return arr;
    }

时间复杂度：O(n^2)

3、插入排序

将序列的第一个元素看做一个有序序列，第二个元素到最后一个元素看做未排序序列。在未排序序列选择元素插入已排序序列的适当位置
如序列【9，1，8，4，6】：
第一轮：【9，1，8，4，6】（整个序列都是未排序序列）
第二轮：【1，9，8，4，6】（已排序序列：1，9；未排序序列：8，4，6）
第三轮：【1，8，9，4，6】（已排序序列：1，8，9；未排序序列：4，6）
第四轮：【1，4，8，9，6】（已排序序列：1，4，8，9；未排序序列：6）
第五轮：【1，4，6，8，9】（整个序列都是已排序序列）

    public int[] sortCR(int[] arr) {
        for(int i = 1;i<arr.length;i++) {
            int min = arr[i];
            for(int j = i-1;j >= 0;j--) {
                if(arr[j] > min) {
                    arr[j+1] = arr[j];
                }else {
                    break;
                }
            }
            arr[j+1] = min;
        }
        return arr;
    }

时间复杂度：O(n^2)

4、希尔排序

选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；按增量序列个数k，对序列进行k趟排序；每趟排序，根据对应的增量ti，将待排序序列分割成若干长度为m的子序列，分别对各子表进行直接插入排序。仅增量因子为1时，整个序列作为一个表来处理。

    public int[] sortXE(int[] arr) {
        int gap = 1;
        while (gap < arr.length) {
            gap = gap * 3 + 1;
        }
        while (gap > 0) {
            for (int i = gap; i < arr.length; i++) {
                int temp = arr[i];
                int j = i - gap;
                while (j >= 0 && arr[j] > temp) {
                    arr[j + gap] = arr[j];
                    j -= gap;
                }
                arr[j+gap] = temp;
            }
            gap = gap / 3;
        }
        return arr;
    }

5、归并排序

核心思想是分治法，将一个数组分为两部分，递归分，直至分为单个元素，然后重组合并，单个元素合并成小数组，小数组合并成大数组，直到最后合并完成，排序完毕。

public int[] sortGB(int[] arr){
        if(arr.length < 2 ){
            return arr;
        }
        int middle = arr.length/2;
        int[] left = Arrays.copyOfRange(arr,0,middle);
        int[] right = Arrays.copyOfRange(arr,middle,arr.length);

        return merge(sortGB(left),sortGB(right));
    }

    /**
     * 合并
     * @param left
     * @param right
     * @return
     */
    public int[] merge(int[] left,int[] right){
        int[] result = new int[left.length + right.length];
        int l = 0;
        int r = 0;
        for(int i = 0;i<result.length;i++){
            if(l > left.length-1){
                result[i] = right[r++];
            }else if(r > right.length-1){
                result[i] = left[l++];
            }else if(left[l] < right[r]){
                result[i] = left[l++];
            }else{
                result[i] = right[r++];
            }
        }
        return result;
    }

6、快速排序

核心思想也是分治法。每次从序列中选出一个基准值，其他元素和基准值比较，比基准值大的放右边，比基准值小的放左边，然后再对左边和右边的两组数分别选出一个基准值，进行同样的比较，重复直至最后都变成单个元素。

    public int[] sortKS(int[] arr){
        sortKS(arr,0,arr.length-1);
        return arr;
    }

    private int[] sortKS(int[] arr,int left,int right){
        if(left < right){
            int partitionIndex = patition(arr,left,right);
            sortKS(arr,left,partitionIndex - 1);
            sortKS(arr,partitionIndex + 1,right);
        }
        return arr;
    }

    public int patition(int[] arr,int left,int right){
        int pivot = left;
        int index = pivot + 1;
        for(int i = index;i<= right;i++){
            if(arr[i] < arr[pivot]) {
                swap(arr,i,index);
                index++;
            }
        }
        swap(arr,pivot,index-1);
        return index-1;
    }

    public int[] swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        return arr;
    }

7、堆排序

对待排序序列创建最大堆，将堆首和堆尾互换；待排序序列减1，重新构建最大堆，再取堆顶的元素；重复步骤，直到堆只剩下一个元素。

    public int[] sortD(int[] arr){
        int len = arr.length;
        /**
         * 构建最大堆
         */
        buildMaxHeap(arr,len);

        for(int i = len-1;i >0;i--){
            swap(arr,0,i);
            len--;
            heapify(arr,0,len);
        }
        return arr;
    }

    /**
     * 构建最大堆
     * @param arr
     */
    public void buildMaxHeap(int[] arr,int len){
        for(int i = len/2;i >=0;i--){
            heapify(arr,i,len);
        }
    }

    public void heapify(int[] arr,int index,int len){
        int left = index * 2 + 1;//左子节点下标
        int right = index * 2 + 2;//右子节点下标
        int preset = index;
        if(left < len && arr[left] > arr[preset]){
            preset = left;
        }
        if(right < len && arr[right] > arr[preset]){
            preset = right;
        }
        if(preset != index) {
            swap(arr, preset, index);
            heapify(arr, preset, len);
        }
    }

8、计数排序

计数排序是一种非基于比较的排序算法。算法：
扫描整个序列，找到最大值max，创建长度为max的新数组，新数组中元素记录的值是index元素出现的次数。最后遍历新数组，输出相应元素以及对应的个数。

 public int[] sortJS(int[] arr) {
     int[] newArr = new int[getMax(arr)+1];
     for(int value:arr) {
         newArr[value] ++;
     }
     
     int index=0;
     for(int i = 0;i < newArr.length;i++) {
         while(newArr[i] > 0) {
             arr[index++] = i;
             newArr[i]--;
         }
     }
     return arr;
 }
public int getMax(int[] arr) {
     int max = arr[0];
     for(int i = 1;i < arr.length;i++) {
         if(arr[i] > max) {
             max = arr[i];
         }
     }
     return max;
 }

计数排序的局限性：
如果要拍的数据范围比较大，比如[1，9999]，如果用计数排序，两个数创建一个int[10000]的数组；如果是[9998,9999]这种虽然数值大但相差范围不大的数据可以用偏移量解决，比如减掉9997后只需要申请int[3]的数组就可以计数。

计数排序只适用于正整数并且取值范围相差不大的数组排序使用，其排序速度快于任何比较型的排序算法。

9、桶排序

桶排序可以看成计数排序的升级版，他将要排序的数据分到多个有序的桶里，每个桶里的数据再单独排序，并把每个桶的数据依次取出。

	public static int[] sortBucket(int[] arr) {
	    //获取最大值和最小值
	    int maxValue = arr[0];
	    int minValue = arr[0];
	    for(int value : arr) {
	        if(value > maxValue) {
	            maxValue = value;
	        }else if(value < minValue){
	            minValue = value;
	        }
	    }
	    
	    //桶列表
	    ArrayList<ArrayList<Integer>> bucketList = new ArrayList<>();
	    for(int i = 0; i < arr.length; i++){
	        bucketList.add(new ArrayList<>());
	    }

	    //每个桶的存数区间
	    int section  = (int) Math.floor((maxValue - minValue) / (arr.length - 1));
	    
	    //数据入桶
	    for(int i=0;i<arr.length;i++) {
	      //当前数除以区间得出存放桶的位置 减1后得出桶的下标
	        int num = (int)(arr[i]/section)-1;
	        if(num < 0){
	            num = 0;
	        }
	        bucketList.get(num).add(arr[i]);
	    }
	    
	    //桶内排序
	    for(int i = 0; i < bucketList.size(); i++) {
	        Collections.sort(bucketList.get(i));
	    }
	    
	  //写入原数组
	    int index = 0;
	    for(ArrayList<Integer> arrayList : bucketList){
	        for(int value : arrayList){
	            arr[index++] = value;
	        }
	    }
	    return arr;
	}

桶排序比较好理解，写代码时需要考虑的问题：

• 桶用什么表示？
  桶是一个可以存放数据的集合，这里使用arrayList。
• 怎么确定桶的数量？
  桶的数量设置为了原数组的长度，理想情况下每个数据装一个桶。
• 桶内排序用什么方法排序？

桶排序的思考及其应用
在额外空间充足的情况下，尽量增大桶的数量，极限情况下每个桶只有一个数据时，或者是每只桶只装一个值时，完全避开了桶内排序的操作，桶排序的最好时间复杂度就能够达到 O(n)。
比如高考总分 750 分，全国几百万人，我们只需要创建 751 个桶，循环一遍挨个扔进去，排序速度是毫秒级。
但是如果数据经过桶的划分之后，桶与桶的数据分布极不均匀，有些数据非常多，有些数据非常少，比如[ 8，2，9，10，1，23，53，22，12，9000 ]这十个数据，我们分成十个桶装，结果发现第一个桶装了 9 个数据，这是非常影响效率的情况，会使时间复杂度下降到 O(nlogn)，解决办法是我们每次桶内排序时判断一下数据量，如果桶里的数据量过大，那么应该在桶里面回调自身再进行一次桶排序。

10、基数排序

基数排序是一种非比较型整数排序的算法，其原理是将数据按位数切割成不同的数字，然后按每个位数分别比较。基数排序可以看成桶排序的扩展，也是用桶来辅助排序

	public static int[] sortJsByBucket(int[] arr) {
	    int maxDigit = getMaxDigit(arr);
	    return radixSort(arr, maxDigit);
    }
	
	private static int[] radixSort(int[] arr, int maxDigit) {
	    //桶列表
	    ArrayList<ArrayList<Integer>> bucketList = new ArrayList<>();
	    //长度为10 装入余数0-9的数据
	    for(int i = 0; i < 10; i++){
	        bucketList.add(new ArrayList());
	    }
	    
	    for(int i = 0;i < maxDigit;i++) {
	        //数据入桶
	        for(int j = 0;j < arr.length;j++) {
	            //计算余数
	            int bucket = ((arr[j] / (int)Math.pow(10,i)) % 10);
	            //放入相应的桶
	            bucketList.get(bucket).add(arr[j]);
	        }
	        //写回数组
	        int pos = 0;
	        int index = 0;
	        for (int k=0;k<10;k++){
	            int size = bucketList.get(k).size();
	            for(int l = 0;l < size;l ++){
	                arr[index++] = bucketList.get(k).get(l);
	            }
	            bucketList.get(k).clear();
	        }
	    }
	    return arr;
    }
    /**
	 * 获取最高位数
	 */
	public static int getMaxDigit(int[] arr) {
	    int maxValue = getMaxValue(arr);
	    return getNumLength(maxValue);
	}
	private static int getNumLength(long num) {
	    if(num == 0) {
	        return 1;
	    }
	    int length = 0;
	    for(long temp = num;temp != 0;temp /=10) {
	        length++;
	    }
	    return length;
	}
	/**
	 * 获取最大值
	 */
    public static int getMaxValue(int[] arr) {
        int maxValue = arr[0];
        for (int value : arr) {
            if (maxValue < value) {
                maxValue = value;
                }
            }
        return maxValue;
    }