2023-03-07 常见的排序算法总结

已于 2023-03-07 02:56:30 修改
阅读量96 收藏
点赞数
分类专栏： 算法 Java 文章标签： 排序算法 算法 数据结构
于 2023-03-07 01:08:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lsg19920625/article/details/129373929
版权
算法 同时被 2 个专栏收录
42 篇文章 0 订阅
订阅专栏
Java
36 篇文章 0 订阅
订阅专栏
本文介绍了十大常见的排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序和基数排序，详细阐述了每种排序算法的基本思路和Java实现，并总结了各种排序算法的特性，如时间复杂度、稳定性以及适用场景。
摘要由CSDN通过智能技术生成

常见的排序算法总结

常见算法可以分为两大类：

  • 非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。

  • 线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。

    算法分类简介

常见算法的时间复杂度

算法详细阐述

1.冒泡排序

思路：外层循环从1到n-1，内循环从当前外层的元素的下一个位置开始，依次和外层的元素比较，出现逆序就交换，通过与相邻元素的比较和交换来把小的数交换到最前面。

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;
        }
    }
}

冒泡排序图示

2.选择排序

思路：冒泡排序是通过相邻的比较和交换，每次找个最小值。选择排序是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

private static void sort(int[] array) {
    int n = array.length;
    for (int i = 0; i < n-1; i++) {
        int min = i;
        for (int j = i+1; j < n; j++) {
            if (array[j] < array[min]){//寻找最小数
                min = j; //将最小数的索引赋值
            }  
        }
        int temp = array[i];
        array[i] = array[min];
        array[min] = temp;

    }
}

3.插入排序

思路：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。可以理解为玩扑克牌时的理牌；

private static void sort(int[] array) {
    int n = array.length;
    // 从第二位数字开始，每一个数字都试图跟它的前一个比较并交换，并重复；直到前一个数字不存在或者比它小或相等时停下来
    for (int i = 1; i < n; i++) {//从第二个数开始
        int key = array[i];
        int j = i -1;
        while (j >= 0 && array[j]>key) {
            array[j + 1] = array[j];  //交换
            j--; //下标向前移动
        }
        array[j+1] = key;
    }
}

插入排序图示

4、希尔排序

思路：希尔排序是插入排序的一种高效率的实现，也叫缩小增量排序。先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录基本有序时再对全体记录进行一次直接插入排序。
问题：增量的序列取法？
　　关于取法，没有统一标准，但最后一步必须是1；因为不同的取法涉及时间复杂度不一样，具体了解可以参考《数据结构与算法分析》；一般以length/2为算法。（再此以gap=gap*3+1为公式）

private static void sort(int[] array) {
    int n = array.length;
    int h = 1;
    while (h<n/3) { //动态定义间隔序列
        h = 3*h +1;
    }
    while (h >= 1) {
        for (int i = h; i < n; i++) {
            for (int j = i; j >= h && (array[j] < array[j - h]); j -= h) {
                int temp = array[j];
                array[j] = array[j - h];
                array[j-h]= temp;
            }
        }
        h /=3;
    }
}

希尔排序图示

5、归并排序

思路：将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。它使用了递归分治的思想；相当于：左半边用尽，则取右半边元素；右半边用尽，则取左半边元素；右半边的当前元素小于左半边的当前元素，则取右半边元素；右半边的当前元素大于左半边的当前元素，则取左半边的元素。

自顶向下的实现：

// "static void main" must be defined in a public class.
public class Main {
    /**
     * 合并区间[low, mid)和[mid, high]使得区间[low, high)有序
     *
     * @param arr  要排序地数组
     * @param low  区间下界
     * @param mid  区间中间
     * @param high 区间上界
     */
    private void merge(int[] arr, int low, int mid, int high) {
        int[] arrTmp = new int[high - low + 1];
        int i = low, j = mid + 1, k = 0;
        // 区间[low, mid)和[mid, high]同步比较
        while (i <= mid && j <= high) {
            // 按照从小到大防放到辅助数组B[]中
            if (arr[i] <= arr[j]) {
                arrTmp[k++] = arr[i++];
            } else {
                arrTmp[k++] = arr[j++];
            }
        }
        // 把两个区间剩余的元素直接放入临时数组arrTmp中
        while (i <= mid) {
            arrTmp[k++] = arr[i++];
        }
        while (j <= high) {
            arrTmp[k++] = arr[j++];
        }
        // 把临时数组设置回原始数组arr中
        for (i = low, k = 0; i <= high; i++) {
            arr[i] = arrTmp[k++];
        }
    }

    /**
     * 基于归并算法的排序
     *
     * @param arr  原始数组
     * @param low  待排序区间下界
     * @param high 待排序区间上界
     */
    void mergeSort(int[] arr, int low, int high) {
        if (low < high) {
            // 取中点
            int mid = (low + high) / 2;
            // 对左右两部分进行归并排序
            mergeSort(arr, low, mid);
            mergeSort(arr, mid+1, high);
            // 把排好序的左右两部分进行合并，相当于递归回退的时候做，类似回溯法了
            merge(arr, low, mid, high);
        }
    }
    public static void main(String[] args) {
        int[] arr = new int[]{42, 15, 20, 6, 8, 38, 50, 12};
        new Main().mergeSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
}

6、快速排序

思路：通过一趟排序将待排记录分隔成独立的两部分()，使得左半部分的数字均比右半部分的数字小…然后递归分别对这两部分数字继续进行排序…最终达到整个序列有序

public class Main {

    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    /**
     * 基准切分，左边小于基准元素，右边大于基准元素
     *
     * @param arr  原始数组
     * @param low  切分区间的下界
     * @param high 切分区间的上界
     * @return 完成最终划分后基准元素所在的位置
     */
    private int partition(int[] arr, int low, int high) {
        // 初始基准元素
        int i = low, j = high, pivot = arr[low];
        while (i < j){
            while (i < j && arr[j] > pivot){
                // 向pivot左侧扫描
                j--;
            }
            if (i < j){
                // arr[i]和arr[j]交换后i向右移动一位
                swap(arr, i++, j);
            }
            while (i < j && arr[i] <=pivot){
                // 向pivot右侧访问
                i++;
            }
            if (i < j){
                // arr[i]和arr[j]交换后j向左移动一位
                swap(arr, i, j--);
            }
        }
        // 返回最终划分完基准元素所在的位置
        return i;
    }

    public void quickSort(int[] arr, int low, int high){
        int mid = 0;
        if (low < high){
            mid = partition(arr, low, high);
            quickSort(arr, low, mid - 1);
            quickSort(arr, mid+1, high);
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[]{30, 24, 5, 58, 18, 36, 12, 42, 39};
        new Main().quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
}
/**
 * [5, 12, 18, 24, 30, 36, 39, 42, 58]
 */

快速排序图示

7、堆排序

思路：堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。Java自带的优先队列java.util.PriorityQueue，默认就是基于大顶堆实现的,具体的优先队列(基于二叉树)的实现参考Part1Basic的第4章和Part2Basic的第8章

// "static void main" must be defined in a public class.
public class Main {
    public void heapSort(int[] arr){
        // 使用Java自带的优先队列，默认就是基于大顶堆实现的,具体的优先队列(基于二叉树)的实现参考Part1Basic的第4章和Part2Basic的第8章
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for(int num : arr){
            pq.add(num);
        }
        for(int i = 0; i < arr.length; i++){
            arr[i] = pq.remove();
        }
    }
    public static void main(String[] args) {
        int[] arr = {49, 38, 65, 97, 76, 13, 27, 49};
        new Main().heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

堆排序举例

8、计数排序

思路：将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

  • 找出待排序的数组中最大和最小的元素；
  • 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
  • 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
  • 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
// "static void main" must be defined in a public class.
public class Main {
    private static int[] countsort(int[] arr) {
		int max=arr[0];
		int min=arr[0];
		
		//step1:得到最大值和最小值，确定构建的数组长度
		for (int i = 0; i < arr.length; i++) {
			
			if(arr[i]>max) {
				max=arr[i];
			}
			if(arr[i]<min) {
				min=arr[i];
			}
		}
		
		//step2:构建一个数组，用来存放每一个数对应出现的次数
		int d=max-min;
		int [] countArray=new int [d+1];
		//统计次数
		for (int i = 0; i < arr.length; i++) {
			countArray[arr[i]-min]++;
		}
		System.out.println("统计不同元素出现的次数："+Arrays.toString( countArray));
		
		//step3:对此时的数组做变形,统计数组从第二个元素开始，每一个元素等于它本身都加上前面所有元素之和。
		for(int i=1;i<countArray.length;i++) {
			countArray[i]+=countArray[i-1];
		}
		System.out.println("变形后的数组："+Arrays.toString( countArray));
		
		//step4:倒序遍历原始数列，从统计数组找到正确位置，输出到结果数组,确保稳定性
		int[] sortedArray = new int[arr.length];
		for(int i=arr.length-1;i>=0;i--) {
			
			sortedArray[countArray[arr[i]-min]-1]=arr[i];
			countArray[arr[i]-min]--;
			
		}
		return sortedArray;
	}
	
	public static void main(String[] args) {
		int arr[]={93,95,98,98,94,92,96,91};
		int[] sortedArray=countsort(arr);
		System.out.println("结果输出："+Arrays.toString(sortedArray));
	}
}

计数排序图示

9、桶排序

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

  • 设置一个定量的数组当作空桶；
  • 遍历输入数据，并且把数据一个一个放到对应的桶里去；
  • 对每个不是空的桶进行排序；
  • 从不是空的桶里把排好序的数据拼接起来。
public class Main {
    private int[] buckets;
    private int[] array;

    public Main(int range,int[] array){
        this.buckets = new int[range];
        this.array = array;
    }

    /*排序*/
    public void sort(){
        if(array!=null && array.length>1){
            for(int i=0;i<array.length;i++){
                buckets[array[i]]++;
            }
        }
    }

    /*排序输出*/
    public void sortOut(){
        //倒序输出数据
        for (int i = 0; i< buckets.length; i++){
            for(int j=0;j<buckets[i];j++){
                System.out.print(i+"\t");
            }      
        }
    }
    public static void main(String[] args) {
        int[] array = {5,7,3,5,4,8,6,4,1,2};
        Main bs = new Main(10, array);
        bs.sort();
        bs.sortOut();//输出打印排序
    }
}

桶排序图示

10、基数排序

思路：基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

  • 取得数组中的最大数，并取得位数；
  • arr为原始数组，从最低位开始取每个位组成radix数组；
  • 对radix进行计数排序（利用计数排序适用于小范围数的特点）；
/**
  * 基数排序
  * 平均O(d(n+r)),最好O(d(n+r)),最坏O(d(n+r));空间复杂度O(n+r);稳定;较复杂
  * d为位数,r为分配后链表的个数
  * 
  *
  */
public class ji_shu {
    //pos=1表示个位，pos=2表示十位
    public static int getNumInPos(int num, int pos) {
        int tmp = 1;
        for (int i = 0; i < pos - 1; i++) {
            tmp *= 10;
        }
        return (num / tmp) % 10;
    }
    //求得最大位数d
    public static int getMaxWeishu(int[] a) {
        int max = a[0];
        for (int i = 0; i < a.length; i++) {
            if (a[i] > max)
                max = a[i];
        }
        int tmp = 1, d = 1;
        while (true) {
            tmp *= 10;
            if (max / tmp != 0) {
                d++;
            } else
                break;
        }
        return d;
    }
    public static void radixSort(int[] a, int d) {
        int[][] array = new int[10][a.length + 1];
        for (int i = 0; i < 10; i++) {
            array[i][0] = 0;
            // array[i][0]记录第i行数据的个数
        }
        for (int pos = 1; pos <= d; pos++) {
            for (int i = 0; i < a.length; i++) {
                // 分配过程
                int row = getNumInPos(a[i], pos);
                int col = ++array[row][0];
                array[row][col] = a[i];
            }
            for (int row = 0, i = 0; row < 10; row++) {
                // 收集过程
                for (int col = 1; col <= array[row][0]; col++) {
                    a[i++] = array[row][col];
                }
                array[row][0] = 0;
                // 复位，下一个pos时还需使用
            }
        }
    }
    public static void main(String[] args) {
        int[] a = { 49, 38, 65, 197, 76, 213, 27, 50 };
        radixSort(a, getMaxWeishu(a));
        System.out.println(Arrays.toString(a));
    }
}

基数排序图示

上面的10种排序算法的特性总结

排序算法要么简单有效，要么是利用简单排序的特点加以改进，要么是以空间换取时间在特定情况下的高效排序。但是这些排序方法都不是固定不变的，需要结合具体的需求和场景来选择甚至组合使用。才能达到高效稳定的目的。没有最好的排序，只有最适合的排序。
　　下面就总结一下排序算法的各自的使用场景和适用场合。

算法适用场景总结

  • 1.从平均时间来看，快速排序是效率最高的，但快速排序在最坏情况下的时间性能不如堆排序和归并排序。而后者相比较的结果是，在n较大时归并排序使用时间较少，但使用辅助空间较多。

  • 2.上面说的简单排序包括除希尔排序之外的所有冒泡排序、插入排序、简单选择排序。其中直接插入排序最简单，但序列基本有序或者n较小时，直接插入排序是好的方法，因此常将它和其他的排序方法，如快速排序、归并排序等结合在一起使用。

  • 3.基数排序的时间复杂度也可以写成O(d*n)。因此它最使用于n值很大而关键字较小的的序列。若关键字也很大，而序列中大多数记录的最高关键字均不同，则亦可先按最高关键字不同，将序列分成若干小的子序列，而后进行直接插入排序。

  • 4.从方法的稳定性来比较，基数排序是稳定的内排方法，所有时间复杂度为O(n^2)的简单排序也是稳定的。但是快速排序、堆排序、希尔排序等时间性能较好的排序方法都是不稳定的。稳定性需要根据具体需求选择。

  • 5.上面的算法实现大多数是使用线性存储结构，像插入排序这种算法用链表实现更好，省去了移动元素的时间。具体的存储结构在具体的实现版本中也是不同的。

空無一悟
关注
专栏目录
Java实现常见排序算法总结
05-02
【Java实现常见排序算法总结】 排序算法是计算机科学中至关重要的一部分，它涉及到数据处理和算法设计。本文将探讨两种常见的排序算法在Java中的实现：直接插入排序和希尔排序。 1. **直接插入排序（直接插入排序...
visual-c---6.0-各种排序的算法-报告及源程序.doc
06-29
报告中，作者选择了选择排序、插入排序和冒泡排序这三种常见的排序算法进行深入探讨，以期读者能对排序算法有更直观的理解。 在设计过程中，作者利用`time()`、`srand()`和`rand()`函数生成了0到99999之间的随机数...
【2023-04-26】排序算法：快速排序，选择排序，插入排序，希尔排序，冒泡排序，归并排序
Actor2的博客
04-26 117
常见的6个排序算法及代码实现：快速排序，选择排序，插入排序，希尔排序，冒泡排序，归并排序。
【愚公系列】软考中级-软件设计师 022-数据结构（排序算法）
时光隧道
01-09 7万+
常见的排序算法有以下几种：冒泡排序（Bubble Sort）：依次比较相邻的两个元素，将较大的元素交换到后面，每一轮比较都将最大的元素放到最后。时间复杂度为O(n^2)。选择排序（Selection Sort）：每次从待排序的元素中选取最小的元素，放置在已排序的末尾。时间复杂度为O(n^2)。插入排序（Insertion Sort）：将待排序的元素插入到已排序的序列中的适当位置，使得插入后仍然有序。时间复杂度平均为O(n2)，最好情况下为O(n)，最坏情况下为O(n2)。
八大排序算法（C语言实现）
热门推荐
2021dragon的博客
05-16 8万+
文章目录插入排序插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序 堆排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
【数据结构】常见八大排序算法总结
m0_64538862的博客
01-16 2367
1.直接插入排序2.希尔排序3.选择排序4.堆排序5.冒泡排序6.快速排序,Hoare版本,挖坑法,前后指针法 快速排序的递归实现 快速排序的非递归实现 7.归并排序8.计数排序（非比较排序）9基数排序 10排序算法的复杂度及稳定性分析
排序和查找算法--总结
qq_36006996的博客
11-16 1431
一、分类 1.内部排序和外部排序　 内部排序：待排序记录存放在计算机随机存储器中（说简单点，就是内存）进行的排序过程。 外部排序：待排序记录的数量很大，以致于内存不能一次容纳全部记录，所以在排序过程中需要对外存进行访问的排序 2.比较类排序和非比较排序 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非.
常见的排序算法汇总（详解篇）
m0_73634434的博客
08-19 3242
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。稳定性 ：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中， r[i]=r[j] ，且 r[i] 在 r[j] 之前，而在排序后的序列中， r[i] 仍在 r[j] 之前，则称这种排序算法是稳定的；否则称为不稳定的。数据元素全部放在内存中的排序。数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
算法学习总结（2）——温故十大经典排序算法
科技D人生
08-29 5万+
一、什么是排序算法 1.1、排序定义 对一序列对象根据某个关键字进行排序。 1.2、排序术语 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；内排序：所有排序操作都在内存中完成；外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；时间复杂度：一个算法执行所耗费的时间。空间...
常见排序算法汇总
夜槿笙歌的博客
04-17 8601
整理一下之前学习的各种排序算法
面试高频考点 -- 常见的排序算法(7种)
qq_45792749的博客
04-27 4828
目录1、直接插入排序2、希尔排序3、选择排序4、5、6、7、 常见排序： 稳定性 两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化。 例如： 1、直接插入排序 从第二个元素开始往后，每次选择一个元素，当前元素前面的区间就是一个有序区间，后面就是无序区间。每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入。 排序12 5 23 6 2 直至整个数组变为有序区间。 /** * 时间复杂度： O(N^2) * 空间复杂度： O(1) * 稳定性： 稳定 *
常见排序算法及其稳定性分析
稻草人敲代码的博客
01-06 1439
排序算法可以说是每一个程序员在学习数据结构和算法时必须要掌握的知识点，同样也是面试过程中可能会遇到的问题，在早些年甚至还会考冒泡排序。由此可见呢，掌握一些常见的排序算法是一个程序员的基本素养。虽然现在的语言标准库里都有直接的排序函数，但是作为一个学习者，我们应当抱着“知其然，还要知其所以然”的态度去学习。1.常见的排序算法有哪些？
常见排序算法总结.pdf
03-28
【排序算法总结】 排序算法是计算机科学中处理数据排列的重要工具，主要分为稳定排序和非稳定排序、内排序和外排序两大类。稳定排序保证了相同元素在排序后的相对位置不变，而非稳定排序则不作此保证。内排序是指...
php-使用php开发的排序算法之BubbleSort-排序算法实现.zip
03-01
在实际应用中，更高效的排序算法如快速排序、归并排序或堆排序等会更为常见。然而，冒泡排序在教学和理解排序算法的基本概念上具有重要意义。 总结一下，这份"php-使用php开发的排序算法之BubbleSort-排序算法实现....
排序算法-基于C语言实现的排序算法之CombSort实现.zip
03-27
本资源聚焦于一种相对不那么常见的排序算法——CombSort（梳排序）。 **CombSort算法** CombSort是一种改进的快速排序算法，由Glenn Sheila和Wendy Hall在1980年提出。它的主要思想是通过模拟梳子的动作来排序数组...
详解八大排序（一）------（插入排序，选择排序，冒泡排序，希尔排序）
2302_80836956的博客
11-16 629
在日常生活中，我们常常要将各种各样的数据进行排序，例如我要将班上的学生按照数学成绩从大到小的排序，像这种一般情况，编译器自带的sort函数就能满足我们的要求。但是，假如我要将班上姓刘的学生按照数学成绩从大到小的排序呢？这种时候，编译器自带的sort函数无法满足需求，我们就需要自己定义一个排序函数。下面我就要介绍目前的八大排序的原理，代码，以及时间，空间复杂度。
插入排序insertsort
cocofu的博客
11-17 245
`range(1, len(arr))`: 生成从1到数组长度减1的数字序列。- 插入 `key` 到 `arr[j + 1]`，即 `arr[0] = 11`，数组变为 `[11, 12, 13, 5, 6]`- 插入 `key` 到 `arr[j + 1]`，即 `arr[0] = 5`，数组变为 `[5, 11, 12, 13, 6]`- 插入 `key` 到 `arr[j + 1]`，即 `arr[1] = 6`，数组变为 `[5, 6, 11, 12, 13]`我们来一步步分析这两种情况。
数字排序的多种方法与实现：从基础到优化
zhaoshanshan168的博客
11-17 226
快速排序 | O(n log n) | O(n²) | 不稳定 | 高效，最常用 || 归并排序 | O(n log n) | O(n log n) | 稳定 | 稳定，适合链表 || 堆排序 | O(n log n) | O(n log n) | 不稳定 | 内存使用少，大数据适用 |快用这些方法试试你的数据吧！
排序算法——直接插入排序详细讲解
最新发布
Xiaodao12345djs的博客
11-17 444
本文详细讲解了排序算法中的直接插入排序的实现原理、代码、时间复杂度及空间复杂度
Sort-Algo：视觉化学习排序算法的新平台
#### 常见排序算法的特点及适用场景 1. **冒泡排序**：通过重复遍历待排序的数组，比较相邻元素，并在需要时交换它们，直到没有更多交换需要进行。它是简单的比较类排序算法，适用于小规模数据集。 2. **插入排序*...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

空無一悟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值