排序算法简介

已于 2022-05-01 00:26:24 修改
阅读量1.2k 收藏 1
点赞数 1
分类专栏： java 数据结构与算法 文章标签： java
于 2020-11-30 17:59:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012485099/article/details/107374303
版权

1. 排序算法的介绍

排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程

2.排序的分类

  1. 内部排序: 指将需要处理的所有数据都加载到内部存储器(内存)中进行排序。
  2. 外部排序法: 数据量过大，无法全部加载到内存中，需要借助外部存储(文件等)进行排序。

3.算法的时间复杂度

3.1度量一个程序(算法)执行时间的两种方法:

  1. 事后统计的方法
    这种方法可行, 但是有两个问题
  • 一是要想对设计的算法的运行性能进行评测，需要实际运行该程序
  • 二是所得时间的统计量依赖于计算机的硬件、软件等环境因素, 这种方式，要在同一台计算机的相同状态下运行，才能比较那个算法速度更快
  1. 事前估算的方法
    通过分析某个算法的时间复杂度来判断哪个算法更优

3.2时间频度

时间频度:一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间
就多。一个算法中的语句执行次数称为语句频度或时间频度。记为 T(n)

3.3时间复杂度

  1. 一般情况下，算法中的基本操作语句的重复执行次数是问题规模 n 的某个函数，用 T(n)表示，若有某个辅 助函数 f(n)，使得当 n 趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称 f(n)是 T(n)的同数量级函数。 记作 T(n)=O( f(n) )，称O( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度。
  2. T(n) 不同，但时间复杂度可能相同。 如:T(n)=n2+7n+6 与 T(n)=3n2+2n+2 它们的 T(n) 不同，但时间复杂 度相同，都为 O(n2)。
  3. 计算时间复杂度的方法:
    ➢ 用常数 1 代替运行时间中的所有加法常数 T(n)=n2+7n+6 => T(n)=n2+7n+1
    ➢ 修改后的运行次数函数中，只保留最高阶项 T(n)=n2+7n+1 => T(n) = n2
    ➢ 去除最高阶项的系数 T(n) = n2 => T(n) = n2 => O(n2)

3.4常见的时间复杂度

在这里插入图片描述

3.5 平均时间复杂度和最坏时间复杂度

排序算法平均时间复杂度最好情况最坏情况空间复杂度排序方式稳定性
冒泡排序O(n^2)O(n)O(n^2)O(1)In-space稳定
选择排序O(n^2)O(n^2)O(n^2)O(1)In-space不稳定
插入排序O(n^2)O(n)O(n^2)O(1)In-space稳定
希尔排序O(n log n)O(n logn)O(n logn)O(1)In-space不稳定
归并排序O(n log n)O(n log n)O(n log n)O(n)Out-space稳定
快速排序O(n log n)O(n log n)O(n^2)O(log n)In-space不稳定
堆排序O(n log n)O(n log n)O(n log n)O(1)In-space不稳定
计数排序O(n + k)O(n + k)O(n + k)O(k)Out-space稳定
桶排序O(n + k)O(n + k)O(n^2)O(n + k)Out-space稳定
基数排序O(n * k)O(n * k)O(n * k)O(n + k)Out-space稳定

3.6相关术语介绍

➢ 稳定:如果a原本在b前面，而a=b，排序之后a仍然在b的前面;
➢ 不稳定:如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面;
➢ 内排序:所有排序操作都在内存中完成;
➢ 外排序:由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行;
➢ 时间复杂度:一个算法执行所耗费的时间。
➢ 空间复杂度:运行完一个程序所需内存的大小。
➢ n: 数据规模
➢ k: “桶”的个数
➢ In-place: 不占用额外内存
➢ Out-place: 占用额外内存

4.算法的空间复杂度简介

  1. 类似于时间复杂度的讨论，一个算法的空间复杂度(SpaceComplexity)定义为该算法所耗费的存储空间，它也是 问题规模 n 的函数。
  2. 空间复杂度(SpaceComplexity)是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的 临时工作单元数与解决问题的规模 n 有关，它随着 n 的增大而增大，当 n 较大时，将占用较多的存储单元，例 如快速排序和归并排序算法, 基数排序就属于这种情况
  3. 在做算法分析时，主要讨论的是时间复杂度。从用户使用体验上看，更看重的程序执行的速度。一些缓存产品 (redis, memcache)和算法(基数排序)本质就是用空间换时间.

5.冒泡排序

在这里插入图片描述
冒泡排序(Bubble Sorting)的思想
通过对待排序序列从前向后(从下标较小的元素开始),依次比较 相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒

public static void baseSort(int[] arr) {
        // 数组最后值 不需要参与排序，因此结束位置为 arr.length - 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]) {
                    ArrayUtils.swap(arr, j, j + 1);
                }
            }
            System.out.println(Arrays.toString(arr));
        }
    }

改进版本一：如果一次排序中发现没有进行交换，说明数组为有序的，此时 停止交换

public static void sort1(int[] arr) {
        // 是否有进行过交换，默认为false，如果没有进行过交换，则表示已经有序了
        boolean hasSwap;
        int temp;
        // 数组最后值 不需要参与排序，因此结束位置为 arr.length - 1
        for (int i = 0; i < arr.length - 1; i++) {
            hasSwap = false;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                // // 当前大于后一个，则交换
                if (arr[j] > arr[j + 1]) {
                    // ArrayUtils.swap(arr, j, j + 1);
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    hasSwap = true;
                }
            }
            if (!hasSwap) {
                break;
            }
        }
    }

改进版本二：如果 当前循环 最后 交换位置为 index ,则下次只需要 遍历至 index - 1

public static void sort(int[] arr) {
        // 分别定义最后交换的位置和当前交换的位置
        int lastSwapIndex, currSwapIndex = arr.length - 1;

        int temp;
        while (currSwapIndex > 0) {
            lastSwapIndex = currSwapIndex;

            currSwapIndex = 0;
            for (int i = 0; i < lastSwapIndex; i++) {
                if (arr[i] > arr[i + 1]) {
                    // ArrayUtils.swap(arr, i, i + 1);
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;

                    currSwapIndex = i;
                }
            }
        }
    }

具体参考 BubbleSort

6.选择排序

选择排序(select sorting)也是一种简单的排序方法。思想为
第一次从 arr[0]~arr[n-1]中选取最小值，与 arr[0]交换
第二次从 arr[1]~arr[n-1]中选取最小值，与 arr[1]交换
第三次从 arr[2]~arr[n-1]中选取最小值，与 arr[2] 交换，…，
第 i 次从 arr[i-1]~arr[n-1]中选取最小值，与 arr[i-1]交换，…,
第 n-1 次从 arr[n-2]~arr[n-1]中选取最小值， 与 arr[n-2]交换，总共通过 n-1 次，得到一个按排序码从小到大排列的有序序列
和冒泡排序(由小至大排序)的区别为：

  • 选择排序每次选出最大值依次放入数组末尾；选择排序每次选出最小值依次放入数组前列
  • 选择排序每次遍历比较时，只是记录下来最小值位置和值，不进行交换，最后比较出来最小值后再进行交换；而冒泡排序则每次遍历比较时都进行交换
public static void sort(int[] arr) {
        int minIndex;
        int minValue;
        for (int i = 0; i < arr.length - 1; i++) {
            // 默认最小值和最小值位置
            minIndex = i;
            minValue = arr[i];

            // 从i位置的后一位和最小值进行比较
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < minValue) {
                    minValue = arr[j];
                    minIndex = j;
                }
            }

            // 如果发现 最小值 不为 初始化的位置才进行交换
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = minValue;
            }
        }
    }

具体参考 SelectSort

7.插入排序

插入排序(Insertion Sorting)的基本思想是
把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排 序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表
冒泡排序在将待插入数值加入有序数组时，不会进行交换，而是将比当前大的值向后进行移动

/**
     * 插入排序
     *
     * @param arr
     */
    public static void sort(int[] arr) {

        //待插入index 和 value
        int insertIndex;
        int insertValue;

        for (int i = 1; i < arr.length; i++) {

            // 待插入数组和值
            insertIndex = i;
            insertValue = arr[i];

            for (int j = i; j > 0; j--) {
                // 如果发现比较值值比前一个值小，则将前一个值向后移
                if (insertValue < arr[j - 1]) {
                    arr[j] = arr[j - 1];
                    // 没有立即将 比较值 和 前一位交换，而是记录下位置
                    insertIndex = j - 1;
                } else {
                    break;
                }
            }

            // 如果待插入位置和i不相等，则进行赋值
            if (insertIndex != i) {
                arr[insertIndex] = insertValue;
            }
        }
    }

    /**
     * 另外一种写法 和 sort 方法理解一致
     *
     * @param arr 待排序数组
     */
    public static void sort1(int[] arr) {

        for (int i = 1; i < arr.length; i++) {
            // insertIndex 为 待插入位置的前一位
            int insertIndex = i - 1;
            // inserValue 为 待插入数据
            int insertValue = arr[i];

            while (insertIndex >= 0 && insertValue < arr[insertIndex]) {
                // 后移一位  insertIndex
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }

            if (insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertValue;
            }
        }
    }

    /**
     * 排序排序
     *
     * @param arr
     */
    public static void sort2(int[] arr) {

        // 存放临时数值
        int tmp;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i; j >= 0; j--) {

                // 将待比较数值存如tmp,待比较数值为 arr[j+1]
                tmp = arr[j + 1];

                // 从j+1一次和前面进行比较，如果发现当前位比前一位小，
                // 则将前一位的数值后移，然后将临时值放入前一位
                if (arr[j + 1] < arr[j]) {
                    arr[j + 1] = arr[j];
                    // 立即将 比较值 和 前一位互换
                    arr[j] = tmp;
                } else {
                    // 发现 arr[j + 1] >= arr[j] 后则进行说明数组已经有序，终止本次内循环
                    break;
                }
            }
        }
    }

8.希尔排序

8.1简单插入排序存在的问题

简单的插入排序可能存在的问题.
数组 arr = {2,3,4,5,6,1} 这时需要插入的数 1(最小), 这样的过程是: {2,3,4,5,6,6} -> {2,3,4,5,5,6} -> {2,3,4,4,5,6} -> {2,3,3,4,5,6} -> {2,2,3,4,5,6} -> {1,2,3,4,5,6}
结论: 当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响

8.2希尔排序简介

希尔排序是希尔(Donald Shell)于 1959 年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序

8.3希尔排序思想

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序;随着增量逐渐减少，每组包含
的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止

8.4实战

/**
     * 希尔排序
     *
     * @param arr
     */
    public static void sort(int[] arr) {

        // 待插入index和value
        int insertIndex;
        int insertValue;

        // {8, 5, 7, 4, 3, 2, 6, 1}  gap为步长  4 -> 2 -> 1
        for (int gap = arr.length / 2; gap >= 1; gap = gap / 2) {

            // 待排序的起始位置
            for (int i = gap; i < arr.length; i++) {
                insertIndex = i;
                insertValue = arr[i];

                // 可以理解为和插入排序一样，插入排序的步长为1，而此时变成了gap
                for (int j = i; j - gap >= 0; j -= gap) {
                    if (arr[j - gap] > insertValue) {
                        insertIndex = j - gap;
                        arr[j] = arr[j - gap];
                    } else {
                        break;
                    }
                }

                if (insertIndex != i) {
                    arr[insertIndex] = insertValue;
                }
            }
        }
    }

    /**
     * 希尔排序，对应插入排序中的 sort2方法改写
     *
     * @param arr
     */
    public static void sort2(int[] arr) {
        int tmp;
        // 步长
        for (int gap = arr.length / 2; gap >= 1; gap = gap / 2) {
            // 循环遍历
            for (int i = 0; i < arr.length; i++) {

                //此时步长已经为gap
                for (int j = i; j >= 0 && j + gap < arr.length; j = j - gap) {
                    tmp = arr[j + gap];
                    if (arr[j + gap] < arr[j]) {
                        arr[j + gap] = arr[j];
                        arr[j] = tmp;
                    } else {
                        break;
                    }
                }
            }
        }
    }

9.快速排序

快速排序(Quicksort)是对冒泡排序的一种改进。基本思想是:通过一趟排序将要排序的数据分割成独立的两 部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排 序，整个排序过程可以递归进行，以此达到整个数据变成有序序列
在这里插入图片描述

public static void sort1(int[] arr, int left, int right) {
        int low = left; //左下标
        int high = right; //右下标

        //pivot 中轴值
        int pivot = arr[(left + right) / 2];

        //临时变量，作为交换时使用
        int temp = 0;
        // while 循环的目的是让比 pivot 值小放到左边
        // 比 pivot 值大放到右边
        while (low < high) {
            //在 pivot 的左边一直找,找到大于等于 pivot 值,才退出
            while (arr[low] < pivot) {
                low += 1;
            }
            //在 pivot 的右边一直找,找到小于等于 pivot 值,才退出
            while (arr[high] > pivot) {
                high -= 1;
            }
            //如果 l >= r 说明 pivot 的左右两的值，已经按照左边全部是 小于等于 pivot 值，右边全部是大于等于 pivot 值,cos
            if (low >= high) {
                break;
            }

            //交换
            temp = arr[low];
            arr[low] = arr[high];
            arr[high] = temp;

            // //如果交换完后，发现 arr[high] == pivot 值 相等 low++， 后移
            // //当数组中有几个值相等时。如果此处不加该判断条件，则永远退出不了循环
            if (arr[high] == pivot) {
                low++;
            }

            //如果交换完后，发现 arr[low] == pivot 值 相等 high--， 前移
            //当数组中有几个值相等时。如果此处不加该判断条件，则永远退出不了循环
            if (arr[low] == pivot) {
                high--;
            }

            System.out.println(Arrays.toString(arr));
            // System.out.println("left:" + l + " right:" + r);
        }

        // 如果 low == high, 必须 low++, high--, 否则为出现栈溢出
        if (low == high) {
            low += 1;
            high -= 1;
        }

        //向左递归
        if (left < high) {
            sort1(arr, left, high);
        }

        //向右递归
        if (right > low) {
            sort1(arr, low, right);
        }
    }

10.归并排序

归并排序(merge-sort)是利用归并的思想实现的排序方法，该算法采用经典的分治(divide-and-conquer) 策略(分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修 补"在一起，即分而治之)
在这里插入图片描述

    /**
     * 归并排序
     * 
     * @param arr
     */
    public static void sort(int[] arr) {
        int[] temp = new int[arr.length];
        splitAndMerge(arr, 0, arr.length - 1, temp);
    }

    /**
     * 拆开阶段
     *
     * @param arr
     * @param left
     * @param right
     * @param temp
     */
    public static void splitAndMerge(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;
            splitAndMerge(arr, left, mid, temp);
            splitAndMerge(arr, mid + 1, right, temp);
            merge(arr,left,mid,right,temp);
        }
    }


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

        int i = left;
        int j = mid + 1;
        int t = 0;

        //1. 先将左右两边(有序) 数据按照规则进行填充 到temp 数组
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                i++;
            } else {
                temp[t] = arr[j];
                j++;
            }

            t++;
        }

        //2. 将剩余数据的一边数据依次全部填充到 temp
        while (i <= mid) {
            temp[t] = arr[i];
            i++;
            t++;
        }

        while (j <= right) {
            temp[t] = arr[j];
            j++;
            t++;
        }

        // 将 临时数组拷贝至arr
        // 注意，并不是每次都拷贝所有
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t++;
            tempLeft++;
        }
    }

11.基数排序

11.1基数排序(桶排序)介绍:

  1. 基数排序(radixsort)属于“分配式排序”(distributionsort)，又称“桶子法”(bucketsort)或binsort，顾 名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
  2. 基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法
  3. 基数排序(RadixSort)是桶排序的扩展
  4. 基数排序是1887年赫尔曼·何乐礼发明的。它是这样实现的:将整数按位数切割成不同的数字，然后按每个
    位数分别比较

11.2基数排序基本思想

将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。
这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列
在这里插入图片描述

public static void sort(int[] arr) {
        // 计算最大值
        int maxValue = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > maxValue) {
                maxValue = arr[i];
            }
        }

        // 最大长度
        int maxLength = String.valueOf(maxValue).length();

        // 排序使用的数组
        int[][] buckets = new int[10][maxLength];
        int[] bucketCnt = new int[10];

        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {

            // 将数据放入桶中
            for (int j = 0; j < arr.length; j++) {
                // 相应位数的数值
                int digitOfEle = arr[j] / n % 10;

                // 将数据放入桶中
                buckets[digitOfEle][bucketCnt[digitOfEle]] = arr[j];
                // 计数+1
                bucketCnt[digitOfEle]++;
            }

            // 从桶中 拿出数据依次放入 原数组中
            int index = 0;
            for (int j = 0; j < 10; j++) {
                for (int k = 0; k < bucketCnt[j]; k++) {
                    arr[index] = buckets[j][k];
                    index++;
                }
                // 清除桶计数
                bucketCnt[j] = 0;
            }

        }
    }

12.排序效率测试

笔者计算机配置：

  • 处理器 2.8 GHz 四核Intel Core i7
  • 内存16 GB 2133 MHz LPDDR3

个人测试结果 测试代码

排序算法时长ms(8W)时长ms(80W)时长ms(80W)时长ms(8000W)
冒泡排序10793、10774、10932跑不出来跑不出来跑不出来
选择排序2845、2802、3019202862、228898、235079跑不出来跑不出来
插入排序585、572、59680229、81328、72114跑不出来跑不出来
希尔排序24、20、28204、191、1942804、2725、280136933、37663、37541
归并排序19、19、24157、144、1241410、1659、138914264、15039、13922
快速排序29、19、22117、108、1041452、1155、104211544、10759、11021
堆排序16、15、16200、248、1932895、3354、286739115、35102、34833
基数排序14、12、1284、101、111580、623、645OOM 6500W(3823、3896、4009)

结论：
可以看到，计数排序是最快的，但是其只适用于数值排序，且需要额外的内存空间，因此用的较少。
相对而言，快速排序和归并排序较快，平时使用较多。归并排序尤其是在多个数组已经排好序的情况下进行merge(此时不需要进行sort)

13实际使用案例介绍

很多框架中大量使用了快速排序和归并排序(多个待合并对象已经排好序)

  • oracle中 sort merge join 使用了归并排序特性(只需merge) 。您可以 查看 1.1.3sort merge join
  • hive中smbj使用了归并排序特性(只需merge) 您可以查看 2.1.4sort merge bucket join(SMBJ)
  • MapReduce中shuffle过程map侧在环形缓冲区溢写前使用了快速排序，溢写后对多个有序文件进行合并时使用了归并排序(只需merge)；reduce侧，对copy过来的多个有序文件进行合并时使用了归并排序(只需merge) 。3.2.4源码解析流程
不名一文
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构与算法 11，互联网大厂面试必问的JVM底层原理
m0_61440508的博客
09-06 721
int min = arr[minIndex]; for(int j = 1 + i;j<arr.length;j++){ if(min > arr[j]){ min = arr[j]; minIndex = j; } } arr[minIndex] = arr[i]; arr[i] = min; } } 4、速度测试 选择排序：120000数...
十种常见排序算法
liyongchunscr的博客
11-16 1万+
0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 0.2 算法复杂度 0.3 相关概念 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 .
八大排序算法——（万字图文详解）
Forward♞的博客
06-28 2164
本篇博客将对“直接插入排序”、“希尔排序”、“直接选择排序”、“堆排序”、“冒泡排序”、“快速排序”、“归并排序”、“计数排序”进行详细的解析（算法逻辑、具体实现过程、时间复杂度、稳定性），并附以图片帮助大家更好地理解算法逻辑以及实现每个排序的参考代码。
排序算法概述
wzx104104104的博客
05-25 305
 https://github.com/githubofrico/DataStructure。 一. 排序算法概述 　　所谓排序，就是根据排序码的递增或者递减顺序把数据元素依次排列起来，使一组任意排列的元素变为一组按其排序码线性有序的元素。本文将介绍八种最为经典常用的内部排序算法，包括插入排序(直接插入排序，希尔排序)、选择排序(直接选择排序，堆排序)、交换排序(冒泡排序，快速排序)
排序算法最全介绍（写的实在太好）
qq_38356760的博客
07-12 322
0、排序算法说明0.1 排序的定义对一序列对象根据某个关键字进行排序。0.2 术语说明稳定：如果a原本在b前面...
简单排序算法简介
11-27
介绍了一些简单的排序算法，比如冒泡法，插入法，选择法，交换法，以及快速排序，还有一些有意思的，比如双向冒泡排序，希尔排序等等。
基于比较的排序算法汇总 选择排序法 插入排序法 归并排序法 快速排序法 堆排序法 冒泡排序法 希尔排序法
最新发布
01-15
在IT领域，排序算法是计算机科学中的基础但至关重要的概念，尤其在数据处理和算法设计中扮演着核心角色。本文将深入探讨标题中提到的几种基于比较的排序算法：选择排序、插入排序、归并排序、快速排序、堆排序、冒泡...
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
java排序算法
09-10
java实现的常用的几种基本排序算法，插入、交换、选择、归并
十大排序算法
10-16
常见10大算法，从原理，动图解析到代码实现，逐步分析，让你轻松入门算法
排序算法大全（概念详细）
04-27
该电子书包含了详细的排序概念覆盖了算法中几乎所有的排序算法，附带插图，以及各排序算法的优劣，总结
几种常见的排序算法
我在这里，就等你来
03-07 1152
昨天刷面经的时候发现这些基本的算法是面试中常见的问题，吓得我赶紧复习了一下。1.冒泡排序原理：从序列尾至头，依次比较两相邻的元素，小的元素左移（前移）大的元素右移（后移）经过 n-1 次起泡后，序列有序。代码：2.插入排序原理：将序列第一个元素视为有序列，其余数视为无序列。从第 2 个数开始，逐个从无序列中取出插入到有序子列中...直至得到完全有序列。代码： 3.快速排序原理：以序列中某个元素 P...
八大排序算法原理及实现
热门推荐
a3192048的博客
05-10 7万+
概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。          当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。    快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布...
常见排序算法_解释的算法-它们是什么以及常见的排序算法
cumi7754的博客
08-15 219
常见排序算法In its most basic form, an algorithm is a set of detailed step-by-step instructions to complete a task. For example, an algorithm to make coffee in a french press would be: 在最基本的形式中，算法是一组完成任务的详细...
排序算法各个算法介绍
zsq543496265的博客
07-01 573
一、基本排序算法 1、 冒泡排序 假如我们现在按身高升序排队，一种排队的方法是：从第一名开始，让两人相互比身高，若前者高则交换位置，更高的那个在与剩下的人比，这样一趟下来之后最高的人就站到了队尾。接着重复以上过程，直到最矮的人站在了队列首部。我们把队头看作水底，队尾看作水面，那么第一趟比较下来，最高的人就像泡泡一样从水底”冒“到水面，第二趟比较则是第二高的人……排队的过程即为对数据对象进行排序的过...
排序算法思路简介
u011414643的专栏
05-21 311
选择排序：   1.排序的过程中，数组分为前后两部分：排序完成的、待排序的部分。                    2.找出未排序数组中的最小值，与排好序数组的后面一个item值进行交换。                    3.交换最少的排序                    4.时间复杂度O(n方)，即比较的次数。插入排序：   1.排序的过程中，数组分为前后两部分：排序完成的、待排...
排序算法介绍
小白鼠丶
08-29 463
排序也称排序算法 (Sort Algorithm)，排序是将一 组数据，依指定的顺序进行排列 的过程。 排序的分类： 1) 内部排序: 指将需要处理的所有数据都加载 到内部存储器中进行排序。 2) 外部排序法： 数据量过大，无法全部加载到内 存中，需要借助外部存储进行 排序。 3) 常见的排序算法分类(见右图): ...
各种排序算法总结和比较
11-30 3000
排序算法可以说是一项基本功，解决实际问题中经常遇到，针对实际数据的特点选择合适的排序算法可以使程序获得更高的效率，有时候排序的稳定性还是实际问题中必须考虑的，这篇博客对常见的排序算法进行整理，包括：插入排序、选择排序、冒泡排序、快速排序、堆排序、归并排序、希尔排序、二叉树排序、计数排序、桶排序、基数排序。 代码都经过了CodeBlocks的调试，但是很可...
Lecture+3-2+List结构的排序编程1
08-04
"本次讲座主要讲解了排序算法的编程实现，特别是针对List结构的排序，包括插入排序(InsertionSort)和归并排序(Mergesort)。讲座还涉及到了函数式编程的一些概念，如整数比较函数compare和判断列表是否有序的函数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值