【排序算法】十大经典大集合:简介-代码-动态图-时间复杂度

【排序算法】十大经典大集合:简介-代码-动态图-时间复杂度_第1张图片

交换排序

      就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置,交换排序的特点是:将键值较大的记录向序列的尾部移动,键值较小的记录向序列的前部移动。
      包括冒泡排序,和快速排序

代码

public static void swapSort(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 temp=array[i];
        array[i]=array[j];
        array[j]=temp;
      }
   }
   }
}

冒泡排序(Bubble Sort)

      从尾部开始比较相邻的两个元素,如果尾部的元素比前面的大,就交换两个元素的位置。
      往前对每个相邻的元素都做这样的比较、交换操作,这样到数组头部时,第 1 个元素会成为最大的元素。
      重新从尾部开始第 1、2 步的操作,除了在这之前头部已经排好的元素。
继续对越来越少的数据进行比较、交换操作,直到没有可比较的数据为止,排序完成。

代码

	public static void bubbleSort(int arr[]) {

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

算法描述

      步骤1: 比较相邻的元素。如果第一个比第二个大,就交换它们两个;
      步骤2: 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数;
      步骤3: 针对所有的元素重复以上的步骤,除了最后一个;
      步骤4: 重复步骤1~3,直到排序完成。

算法分析

      最佳情况:T(n) = O(n)
      最差情况:T(n) = O(n2)
      平均情况:T(n) = O(n2)

效果

在这里插入图片描述

快速排序(Quick Sort)

      基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列

代码

public static int[] qsort(int arr[],int start,int end) {        
    int pivot = arr[start];        
    int i = start;        
    int j = end;        
    while (i<j) {            
        while ((i<j)&&(arr[j]>pivot)) {                
            j--;            
        }            
        while ((i<j)&&(arr[i]<pivot)) {                
            i++;            
        }            
        if ((arr[i]==arr[j])&&(i<j)) {                
            i++;            
        } else {                
            int temp = arr[i];                
            arr[i] = arr[j];                
            arr[j] = temp;            
        }        
    }        
    if (i-1>start) arr=qsort(arr,start,i-1);        
    if (j+1<end) arr=qsort(arr,j+1,end);        
    return (arr);    
}   

算法描述

      步骤1:从数列中挑出一个元素,称为 “基准”(pivot );
      步骤2:重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;
      步骤3:递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。

算法分析

      最佳情况:T(n) = O(nlogn)
      最差情况:T(n) = O(n2)
      平均情况:T(n) = O(nlogn)

效果

【排序算法】十大经典大集合:简介-代码-动态图-时间复杂度_第2张图片

插入排序

      对于少量元素的排序,它是一个有效的算法。插入排序是一种最简单的排序方法,它的基本思想是将一个记录插入到已经排好序的有序表中,从而一个新的、记录数增1的有序表。在其实现过程使用双层循环,外层循环对除了第一个元素之外的所有元素,内层循环对当前元素前面有序表进行待插入位置查找,并进行移动。

代码

public static void sort(Comparable[] a)
    {
        //将a[]按升序排列
        int N=a.length;
        for (int i=1;i<N;i++)
        {
        //将a[i]插入到a[i-1],a[i-2],a[i-3]……之中
            for(int j=i;j>0&&(a[j].compareTo(a[j-1])<0);j--)
            {
                Comparable temp=a[j];
                a[j]=a[j-1];
                a[j-1]=temp;
            }
        }
    }

直接插入排序(Insertion Sort)

      直接插入排序(Straight Insertion Sort)是一种最简单的排序方法,其基本操作是将一条记录插入到已排好的有序表中,从而得到一个新的、记录数量增1的有序表。

代码

public void insertSort(int[] array){
        for(int i=1;i<array.length;i++)//第0位独自作为有序数列,从第1位开始向后遍历
        {
            if(array[i]<array[i-1])//0~i-1位为有序,若第i位小于i-1位,继续寻位并插入,否则认为0~i位也是有序的,忽略此次循环,相当于continue
            {
                int temp=array[i];//保存第i位的值
                int j = i - 1;
                while(j>=0 && temp<array[j])//从第i-1位向前遍历并移位,直至找到小于第i位值停止
                {
                    array[j+1]=array[j];
                    j--;
                }
                array[j+1]=temp;//插入第i位的值
            }
        } 
    }

算法描述

      步骤1: 从第一个元素开始,该元素可以认为已经被排序;
      步骤2: 取出下一个元素,在已经排序的元素序列中从后向前扫描;
      步骤3: 如果该元素(已排序)大于新元素,将该元素移到下一位置;
      步骤4: 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;
      步骤5: 将新元素插入到该位置后;
      步骤6: 重复步骤2~5。

算法分析

      最佳情况:T(n) = O(n)
      最坏情况:T(n) = O(n2)
      平均情况:T(n) = O(n2)

效果

【排序算法】十大经典大集合:简介-代码-动态图-时间复杂度_第3张图片

希尔排序(Shell Sort)

      希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”(Diminishing Increment Sort),是直接插入排序算法的一种更高效的改进版本。
希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至 1 时,整个文件恰被分成一组,算法便终止。

代码

public static int[] ShellSort(int[] array) {
        int len = array.length;
        int temp, gap = len / 2;
        while (gap > 0) {
            for (int i = gap; i < len; i++) {
                temp = array[i];
                int preIndex = i - gap;
                while (preIndex >= 0 && array[preIndex] > temp) {
                    array[preIndex + gap] = array[preIndex];
                    preIndex -= gap;
                }
                array[preIndex + gap] = temp;
            }
            gap /= 2;
        }
        return array;

算法描述

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

算法分析

      最佳情况:T(n) = O(nlog2 n)
      最坏情况:T(n) = O(nlog2 n)
      平均情况:T(n) =O(nlog2n)

效果

选择排序

简单选择排序 (Selection Sort)

      选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是:第一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找到最小(大)元素,然后放到已排序的序列的末尾。以此类推,直到全部待排序的数据元素的个数为零

代码

public static void selectionSort(int[] arr) {
        int min, temp;
        for (int i = 0; i < arr.length; i++) {
            // 初始化未排序序列中最小数据数组下标
            min = i;
            for (int j = i+1; j < arr.length; j++) {
                // 在未排序元素中继续寻找最小元素,并保存其下标
                if (arr[j] < arr[min]) {
                    min = j;
                }
            }
            // 将未排序列中最小元素放到已排序列末尾
            if (min != i) {
                temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
    }

算法描述

      步骤1:初始状态:无序区为R[1…n],有序区为空;
      步骤2:第i趟排序(i=1,2,3…n-1)开始时,当前有序区和无序区分别为R[1…i-1]和R(i…n)。该趟排序从当前无序区中-选出关键字最小的记录 R[k],将它与无序区的第1个记录R交换,使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区;
步骤3:n-1趟结束,数组有序化了。

算法分析

      最佳情况:T(n) = O(n2)
      最差情况:T(n) = O(n2)
      平均情况:T(n) = O(n2)

效果

在这里插入图片描述

堆排序(Heap Sort)

      堆是具有以下性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值,称为大顶堆;或者每个结点的值都小于或等于其左右孩子结点的值,称为小顶堆。
堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。

代码

 * 选择排序-堆排序
    * @param array 待排序数组
    * @return 已排序数组
    */
    public static int[] heapSort(int[] array) {
        //这里元素的索引是从0开始的,所以最后一个非叶子结点array.length/2 - 1
        for (int i = array.length / 2 - 1; i >= 0; i--) {  
            adjustHeap(array, i, array.length);  //调整堆
        }
  
        // 上述逻辑,建堆结束
        // 下面,开始排序逻辑
        for (int j = array.length - 1; j > 0; j--) {
            // 元素交换,作用是去掉大顶堆
            // 把大顶堆的根元素,放到数组的最后;换句话说,就是每一次的堆调整之后,都会有一个元素到达自己的最终位置
            swap(array, 0, j);
            // 元素交换之后,毫无疑问,最后一个元素无需再考虑排序问题了。
            // 接下来我们需要排序的,就是已经去掉了部分元素的堆了,这也是为什么此方法放在循环里的原因
            // 而这里,实质上是自上而下,自左向右进行调整的
            adjustHeap(array, 0, j);
        }
        return array;
    }
  
    /**
    * 整个堆排序最关键的地方
    * @param array 待组堆
    * @param i 起始结点
    * @param length 堆的长度
    */
    public static void adjustHeap(int[] array, int i, int length) {
        // 先把当前元素取出来,因为当前元素可能要一直移动
        int temp = array[i];
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {  //2*i+1为左子树i的左子树(因为i是从0开始的),2*k+1为k的左子树
            // 让k先指向子节点中最大的节点
            if (k + 1 < length && array[k] < array[k + 1]) {  //如果有右子树,并且右子树大于左子树
                k++;
            }
            //如果发现结点(左右子结点)大于根结点,则进行值的交换
            if (array[k] > temp) {
                swap(array, i, k);
                // 如果子节点更换了,那么,以子节点为根的子树会受到影响,所以,循环对子节点所在的树继续进行判断
                    i  =  k;
                        } else {  //不用交换,直接终止循环
                break;
            }
        }
    }
  
    /**
    * 交换元素
    * @param arr
    * @param a 元素的下标
    * @param b 元素的下标
    */
    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

算法描述

      步骤1:将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆,此堆为初始的无序区;
      步骤2:将堆顶元素R[1]与最后一个元素R[n]交换,此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n];
      步骤3:由于交换后新的堆顶R[1]可能违反堆的性质,因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆,然后再次将R[1]与无序区最后一个元素交换,得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1,则整个排序过程完成。

算法分析

      最佳情况:T(n) = O(nlogn)
      最差情况:T(n) = O(nlogn)
      平均情况:T(n) = O(nlogn)

效果

归并

归并排序(Merge Sort)

      归并排序(Merge Sort)是建立在归并操作上的一种有效,稳定的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。

代码

public class MergeSort {
    public static void main(String[] args) {
    
        int arr[] = {8, 4, 5, 7, 1, 3, 6, 2};
        int temp[] = new int[arr.length]; //归并排序需要一个额外空间
        
        mergeSort(arr, 0, arr.length - 1, temp);
        System.out.println("排序后的结果为:" + Arrays.toString(arr));
	}


    //分 + 合方法:先递归分,再合
    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if(left < right) {
            int mid = (left + right) / 2; //中间索引
            //向左递归进行分解
            mergeSort(arr, left, mid, temp);
            //向右递归进行分解
            mergeSort(arr, mid + 1, right, temp);
            //合并
            merge(arr, left, mid, right, temp);
        }
    }

    /**
     * 合并的方法
     * @param arr 待排序的原始数组
     * @param left 左边有序序列的初始索引
     * @param mid 中间索引
     * @param right 右边索引
     * @param temp 做中转的数组
     */
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {

        int i = left; // 初始化i, 左边有序序列的初始索引
        int j = mid + 1; //初始化j, 右边有序序列的初始索引
        int t = 0; // 指向temp数组的当前索引

        //(一)
        //先把左右两边(有序)的数据按照规则填充到temp数组
        //直到左右两边的有序序列,有一边处理完毕为止
        while (i <= mid && j <= right) { //继续
            //如果左边的有序序列的当前元素,小于等于右边有序序列的当前元素
            //即将左边的当前元素,填充到temp数组
            //然后 t++, i++
            if(arr[i] <= arr[j]) {
                temp[t] = arr[i];
                t = t + 1;
                i = i + 1;
            } else { //反之,将右边有序序列的当前元素,填充到temp数组
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
        }

        //(二)
        //把有剩余数据的一边的数据依次全部填充到temp
        while( i <= mid) { //左边的有序序列还有剩余的元素,就全部填充到temp
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }
        while( j <= right) { //右边的有序序列还有剩余的元素,就全部填充到temp
            temp[t] = arr[j];
            t += 1;
            j += 1;
        }

        //(三)
        //将temp数组的元素拷贝到arr
        //注意,并不是每次都拷贝所有,这句话和递归有关,要理解有一定的难度
        //因为这里并不是全部分完之后再合,而是分一点合一点
        t = 0;
        int tempLeft = left; //
        //第一次合并 tempLeft = 0 , right = 1 //  tempLeft = 2  right = 3 // tL=0 ri=3
        //最后一次 tempLeft = 0  right = 7
        while(tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t += 1;
            tempLeft += 1;
        }
    }
}

算法描述

      步骤1:把长度为n的输入序列分成两个长度为n/2的子序列;
      步骤2:对这两个子序列分别采用归并排序;
      步骤3:将两个排序好的子序列合并成一个最终的排序序列。

算法分析

      最佳情况:T(n) = O(n)
      最差情况:T(n) = O(nlogn)
      平均情况:T(n) = O(nlogn)

效果

在这里插入图片描述

非比较排序-牺牲空间

计数排序(Counting Sort)

      计数排序是一个非基于比较的排序算法。它的优势在于在对一定范围内的整数排序时,它的复杂度为Ο(n+k)(其中k是整数的范围),快于任何比较排序算法。当然这是一种牺牲空间换取时间的做法,而且当O(k)>O(nlog(n))的时候其效率反而不如基于比较的排序(基于比较的排序的时间复杂度在理论上的下限是O(nlog(n)), 如归并排序,堆排序)

代码

 public static int[] countSort(int[]a){
        int b[] = new int[a.length];
        int max = a[0],min = a[0];
        for(int i:a){
            if(i>max){
                max=i;
            }
            if(i<min){
                min=i;
            }
        }//这里k的大小是要排序的数组中,元素大小的极值差+1
        int k=max-min+1;
        int c[]=new int[k];
        for(int i=0;i<a.length;++i){
            c[a[i]-min]+=1;//优化过的地方,减小了数组c的大小
        }
        // 计数数组变形,新元素的值是前面元素累加之和的值
        // 这里解释一下,c的index表示跟最小数的差值,value代表这样的数有几个,
        //这样我们就能确定最终位置了。比如C[0]=1,c[1]=0,c=[2]=2
        //当a[i]-min=0时,也就是该a[i]就是最小的,b[0]=a[i],从0开始,所以c[a[i]-min]-1
        //当a[i]-min=1时,由于c[1]=0,也就没有差值为1的数,故不会出现这种情况(这也是不用循环c的原因)
        //当a[i]-min=2时,也就是差值为2,该a[i]应该放在比差值2还小的所有数的后边,由于需要前边的总数,所以就有了c[i]=c[i]+c[i-1]
        //此时c[a[i]-min]=3,由于差值为2的共两个数,所以应该放在第2位和第3位,这里我们i=a.length-1是从后往前循环的,所以也就从后往前放,先放第三位,count[A[j]-min]--=1,此后再出现该数就会放在第2位
        //由此可以看出计数排序是稳定的
        for(int i=1;i<c.length;++i){
			c[i]=c[i]+c[i-1];
		}
		for(int i=a.length-1;i>=0;--i){
			b[c[a[i]-min]-1]=a[i];//按存取的方式取出c的元素
			count[A[j]-min]--;
		}
    	return b;
    }

算法描述

      步骤1:找出待排序的数组中最大和最小的元素;
      步骤2:创建新的数组C(大小为上边俩数差加1),统计原数组中每个值为i的元素出现的次数,存入数组C的第i项;
      步骤3:对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加);
      步骤4:反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1。

算法分析

      当输入的元素是n 个0到k之间的整数时,它的运行时间是 O(n + k)。计数排序不是比较排序,排序的速度快于任何比较排序算法。由于用来计数的数组C的长度取决于待排序数组中数据的范围(等于待排序数组的最大值与最小值的差加上1),这使得计数排序对于数据范围很大的数组,需要大量时间和内存。

      最佳情况:T(n) = O(n+k)
      最差情况:T(n) = O(n+k)
      平均情况:T(n) = O(n+k)

效果

在这里插入图片描述

桶排序(Bucket Sort)

      桶排序 (Bucket sort)或所谓的箱排序,工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序(有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序)。桶排序是鸽巢排序的一种归纳结果。当要被排序的数组内的数值是均匀分配的时候,桶排序使用线性时间(Θ(n))。但桶排序并不是 比较排序,他不受到 O(n log n) 下限的影响。

代码

public static void bucketSort(int[] arr){
    
    // 计算最大值与最小值
    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;
    for(int i = 0; i < arr.length; i++){
        max = Math.max(max, arr[i]);
        min = Math.min(min, arr[i]);
    }
    
    // 计算桶的数量
    int bucketNum = (max - min) / arr.length + 1;
    ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
    for(int i = 0; i < bucketNum; i++){
        bucketArr.add(new ArrayList<Integer>());
    }
    
    // 将每个元素放入桶
    for(int i = 0; i < arr.length; i++){
        int num = (arr[i] - min) / (arr.length);
        bucketArr.get(num).add(arr[i]);
    }
    
    // 对每个桶进行排序
    for(int i = 0; i < bucketArr.size(); i++){
        Collections.sort(bucketArr.get(i));
    }
    
    // 将桶中的元素赋值到原序列
	int index = 0;
	for(int i = 0; i < bucketArr.size(); i++){
		for(int j = 0; j < bucketArr.get(i).size(); j++){
			arr[index++] = bucketArr.get(i).get(j);
		}
	}  
}

算法分析

      桶排序最好情况下使用线性时间O(n),桶排序的时间复杂度,取决与对各个桶之间数据进行排序的时间复杂度,因为其它部分的时间复杂度都为O(n)。很显然,桶划分的越小,各个桶之间的数据越少,排序所用的时间也会越少。但相应的空间消耗就会增大。
      最佳情况:T(n) = O(n+k)
      最差情况:T(n) = O(n+k)
      平均情况:T(n) = O(n2)

基数排序(Radix Sort)

      基数排序(radix sort)属于“分配式排序”(distribution sort),又称“桶子法”(bucket sort)或bin sort,是桶排序的扩展,它的基本思想是:将整数按位数切割成不同的数字,然后按每个位数分别比较。
      基数排序是按照低位先排序,然后收集;再按照高位排序,然后再收集;依次类推,直到最高位.
      有时候有些属性是有优先级顺序的,先按低优先级排序,再按高优先级排序.最后的次序就是高优先级高的在前,高优先级相同的低优先级高的在前.

代码

public static void sort(int[] number) //d表示最大的数有多少位
	{
		int max = 0;
		for (int i=0;i<number.length;i++){
			if (max<number[i]){
				max = number[i];
			}
		}
		//获取最大值位数;
		int times = 0;
		while (max>0){
			max/=10;times++;//求取这个最大值的位数,依次除以10;直到为0;
		}

		int k = 0;
		int n = 1; //个位1,十位10,百位100···
		int m = 1; //控制键值排序依据在哪一位
		int[][] temp = new int[10][number.length]; //数组的第一维表示可能的余数0-9
		int[] order = new int[10]; //数组orderp[i]用来表示该位是i的数的个数
		while(m <= times)  //从个位开始排序
		{
			for(int i = 0; i < number.length; i++)
			{
				int lsd = ((number[i] / n) % 10);  //获取当前位的值
				// temp用来存放当前位lsd上的数number[i],order用来记录当前位lsd上存放了多少个数
				temp[lsd][order[lsd]] = number[i];
				order[lsd]++;
			}
			//order[i] 用来存放当前位是i(0-9)的个数
			//然后从0开始,再按照存放顺序,取出,从而得到从小到大的序列
			for(int i = 0; i < 10; i++)
			{
				if(order[i] != 0)
					for(int j = 0; j < order[i]; j++)
					{
						number[k] = temp[i][j];
						k++;

					}
				// 清空记数
				order[i] = 0;
			}
			n *= 10; //升位
			k = 0; //从头开始
			m++; //升位
		}
	}

效果

在这里插入图片描述

总结

【排序算法】十大经典大集合:简介-代码-动态图-时间复杂度_第4张图片

      O(n)这样的标志叫做渐近时间复杂度,是个近似值.各种渐近时间复杂度由小到大的顺序如下
      O(1 )< O(logn) < O(n) < O(n*logn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)

比较排序

      常见的选择排序、归并排序、插入排序、交换排序 等属于比较排序 。在排序的最终结果里,元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较,才能确定自己的位置 。
      比较排序的优势是,适用于各种规模的数据,也不在乎数据的分布,都能进行排序。可以说,比较排序适用于一切需要排序的情况。

非比较排序

      计数排序、基数排序、桶排序则属于非比较排序 。非比较排序是通过确定每个元素之前,应该有多少个元素来排序。针对数组arr,计算arr[i]之前有多少个元素,则唯一确定了arr[i]在排序后数组中的位置 。
      非比较排序只要确定每个元素之前的已有的元素个数即可,所有一次遍历即可解决。算法时间复杂度O(n)。
      非比较排序时间复杂度底,但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

参考:
https://www.jianshu.com/p/1458abf81adf
https://blog.csdn.net/weixin_41190227/article/details/86600821
插入排序

你可能感兴趣的:(算法,排序算法,数据结构,java,算法,其他)