数据结构 —— 八大排序（超详细图解 & 函数实现）

已于 2023-02-23 14:44:52 修改
阅读量2.7k 收藏 18
点赞数 16
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 数据结构 排序算法 算法 c++ c语言
于 2022-09-04 15:11:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_64589446/article/details/126686713
本文详细介绍了插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序和计数排序这八大排序算法，包括它们的基本思想、图解、代码实现和特性。其中，插入排序、冒泡排序和选择排序时间复杂度为O(N^2)，而快速排序和归并排序平均时间复杂度为O(N*log2N)，堆排序和计数排序则各有优缺点，适用于不同场景。文章最后对这些排序算法进行了比较，并指出排序算法在解决实际问题中的重要性。

系列文章目录

数据结构 —— 顺序表
数据结构 —— 单链表
数据结构 —— 双向链表
数据结构 —— 队列
数据结构 —— 栈
数据结构 —— 堆
数据结构 —— 二叉树
数据结构 —— 八大排序

文章目录

前言

排序算法主要分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、计数排序等。本文将针对上述八大排序算法进行图解剖析。

一、排序分类

请添加图片描述

二、排序算法

● 插入排序

1.思想

直接插入排序: 把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

实际中我们玩扑克牌时，就用了插入排序的思想。
在这里插入图片描述

2.图解

请添加图片描述

3.代码

// 插入排序
void InsertSort(int *arr, int size) {
    for (int i = 1; i < size; i++) {
        int num = arr[i];
        int end = i - 1;
        for (; end >= 0; end--) {
            if (arr[end] > num) {
                arr[end + 1] = arr[end];
            } else {
                break;
            }
        }
        arr[end + 1] = num;
    }
}

4.特性

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：O(N2)
  3. 空间复杂度：O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定

● 希尔排序

1.思想

希尔排序（缩小增量排序）: 先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

2.图解

在这里插入图片描述

3.代码

// 希尔排序
void ShellSort(int *arr, int size) {
    int gap = size;
    while (gap > 1) {   // 降gap
        gap = gap / 3 + 1;
        for (int cur = gap; cur < size; cur++) {    // 排序
            int num = arr[cur];
            int end = cur - gap;
            for (; end >= 0; end -= gap) {
                if (arr[end] > num) {
                    arr[end + gap] = arr[end];
                } else {
                    break;
                }
            }
            arr[end + gap] = num;
        }
    }
}

4.特性

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定。因为gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，于是时间复杂度我们就取用：O(N1.3) ~ O(N2)

● 选择排序

1.思想

直接选择排序: 每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

2.图解

  • 在元素集合array[ i ] ~ array[ n - 1 ]中选择关键码最大(小)的数据元素
  • 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
  • 在剩余的array[ i ] ~ array[ n - 2 ] (array[ i + 1 ] ~ array[ n - 1 ]) 集合中，重复上述步骤，直到集合剩余1个元素

请添加图片描述

3.代码

// 算法 数值交换
void Swap(void *A, void *B, int size) {
    while (size--) {
        char tmp = *(char *)A;
        *(char *)A = *(char *)B;
        *(char *)B = tmp;
        A = (char *)A + 1;
        B = (char *)B + 1;
    }
}

// 最坏最好都是(n ^ 2)
void SelectSort(int *a, int n) {
    int begin = 0, end = n - 1;
    while (begin < end) {
        // 选出最小的放begin位置
        // 选出最大的放end位置
        int mini = begin, maxi = begin;
        for (int i = begin + 1; i <= end; ++i) {
            if (a[i] > a[maxi]) {
                maxi = i;
            }

            if (a[i] < a[mini]) {
                mini = i;
            }
        }

        Swap(&a[begin], &a[mini], sizeof(int));
        // 修正一下maxi
        if (maxi == begin) {
            maxi = mini;
        }
        Swap(&a[end], &a[maxi], sizeof(int));
        ++begin;
        --end;
    }
}

4.特性

  1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
  2. 时间复杂度：O(N2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

● 堆排序

1.思想

堆排序(Heapsort): 是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

2.图解

在这里插入图片描述

3.代码

#define BIGHEAP >       // 大堆
#define SMAHEAP <       // 小堆
#define CMP BIGHEAP

typedef int DataType;

// 算法 数值交换
void Swap(void *A, void *B, int size) {
    while (size--) {
        char tmp = *(char *)A;
        *(char *)A = *(char *)B;
        *(char *)B = tmp;
        A = (char *)A + 1;
        B = (char *)B + 1;
    }
}

// 算法 向下调整
void AdjustDown(DataType *array, int size, int parent) {
    int child = parent * 2 + 1;
    while (child < size) {
        // 找出最小的孩子
        if (child + 1< size && array[child + 1] CMP array[child]) {
            child++;
        }
        // 判断下调
        if (array[child] CMP array[parent]) {
            Swap(&array[child], &array[parent], sizeof(DataType));
            parent = child;
            child = parent * 2 + 1;
        } else {
            break;
        }
    }
}

// 堆排序
void HeapSort(int *array, int size) {
    for (int i = (size - 2) / 2; i >= 0; i--) {     //O(N)
        AdjustDown(array, size, i);
    }
    for (int i = 1; i < size; i++) {                //O(N * logN)
        Swap(&array[0], &array[size - i], sizeof(int));
        AdjustDown(array, size - i, 0);
    }
}

4.特性

  1. 堆排序使用堆来选数，效率就高了很多。
  2. 时间复杂度：O(N * log2N)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

● 冒泡排序

1.思想

冒泡排序: ：冒泡排序即交换排序，所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

2.图解

请添加图片描述

3.代码

// 算法 数值交换
void Swap(void *A, void *B, int size) {
    while (size--) {
        char tmp = *(char *)A;
        *(char *)A = *(char *)B;
        *(char *)B = tmp;
        A = (char *)A + 1;
        B = (char *)B + 1;
    }
}

// 最坏O(N ^ 2)
// 最好O(N)
void BubbleSort(int *arr, int size) {
    for (int i = size; i > 0; i--) {
        int exchange = 0;
        for (int j = 1; j < i; j++) {
            if (arr[j - 1] > arr[j]) {
                exchange = 1;
                Swap(&arr[j - 1], &arr[j], sizeof(int));
            }
        }
        if (exchange == 0) {
            break;
        }
    }
}

4.特性

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

● 快速排序

1.思想

快速排序: 任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

2.图解

  • hoare版本
    请添加图片描述

  • 挖坑法

请添加图片描述

  • 双指针法
    请添加图片描述

3.代码

  • hoare版本
// 插入排序
void InsertSort(int *arr, int size) {
    for (int i = 1; i < size; i++) {
        int num = arr[i];
        int end = i - 1;
        for (; end >= 0; end--) {
            if (arr[end] > num) {
                arr[end + 1] = arr[end];
            } else {
                break;
            }
        }
        arr[end + 1] = num;
    }
}

// 算法 数值交换
void Swap(void *A, void *B, int size) {
    while (size--) {
        char tmp = *(char *)A;
        *(char *)A = *(char *)B;
        *(char *)B = tmp;
        A = (char *)A + 1;
        B = (char *)B + 1;
    }
}

// 取中间值
int GetMidIndex(int *arr, int left, int right) {
    int mid = left + (right - left) / 2;    // 防止相加溢出
    if ((arr[mid] <= arr[left] && arr[left] <= arr[right]) || (arr[mid] >= arr[left] && arr[left] >= arr[right])) {
        return left;
    } else if ((arr[mid] <= arr[right] && arr[right] <= arr[left]) || (arr[mid] >= arr[right] && arr[right] >= arr[left])) {
        return right;
    } else {
        return mid;
    }
}

// 单趟排序
int PartSort(int *arr, int left, int right) {
    int mid = GetMidIndex(arr, left, right);
    Swap(&arr[left], &arr[mid], sizeof(int));

    int keyi = left;
    while (left < right) {
        // R找小
        while (left < right && arr[right] >= arr[keyi]) {
            right--;
        }
        // L找大
        while (left < right && arr[left] <= arr[keyi]) {
            left++;
        }
        if (left < right) {
            Swap(&arr[left], &arr[right], sizeof(int));
        }
    }
    Swap(&arr[keyi], &arr[left], sizeof(int));
    return left;
}

// 快速排序
void QuickSort(int *arr, int begin, int end) {
    if (begin >= end) {
        return;
    }
    if (end - begin <= 8) {
        InsertSort(arr + begin, end - begin + 1);
    } else {
        int keyi = PartSort(arr, begin, end);   // 算出枢轴值
        QuickSort(arr, begin, keyi - 1);            // 对低子表递归排序
        QuickSort(arr, keyi + 1, end);            // 对高子表递归排序
    }
}
  • 挖坑法
// 插入排序
void InsertSort(int *arr, int size) {
    for (int i = 1; i < size; i++) {
        int num = arr[i];
        int end = i - 1;
        for (; end >= 0; end--) {
            if (arr[end] > num) {
                arr[end + 1] = arr[end];
            } else {
                break;
            }
        }
        arr[end + 1] = num;
    }
}

// 算法 数值交换
void Swap(void *A, void *B, int size) {
    while (size--) {
        char tmp = *(char *)A;
        *(char *)A = *(char *)B;
        *(char *)B = tmp;
        A = (char *)A + 1;
        B = (char *)B + 1;
    }
}

// 取中间值
int GetMidIndex(int *arr, int left, int right) {
    int mid = left + (right - left) / 2;    // 防止相加溢出
    if ((arr[mid] <= arr[left] && arr[left] <= arr[right]) || (arr[mid] >= arr[left] && arr[left] >= arr[right])) {
        return left;
    } else if ((arr[mid] <= arr[right] && arr[right] <= arr[left]) || (arr[mid] >= arr[right] && arr[right] >= arr[left])) {
        return right;
    } else {
        return mid;
    }
}

// 单趟排序
int PartSort(int *arr, int left, int right) {
    // 三数取中
    int mid = GetMidIndex(arr, left, right);
    Swap(&arr[left], &arr[mid], sizeof(int));

    int hole = left;                                    // 记录坑hole
    int key = arr[left];                                // 记录key
    while (left < right) {                              // 左右相遇
        while (left < right && key <= arr[right]) {     // 找右边比坑小的位置
            right--;
        }
        arr[hole] = arr[right];                         // 填坑
        hole = right;                                   // 新坑位

        while (left < right && key >= arr[left]) {      // 找左边比坑大的位置
            left++;
        }
        arr[hole] = arr[left];                          // 填坑
        hole = left;                                    // 新坑位
    }
    arr[hole] = key;                                    // key填入坑
    return hole;
}

// 快速排序
void QuickSort(int *arr, int begin, int end) {
    if (begin >= end) {
        return;
    }
    if (end - begin <= 8) {
        InsertSort(arr + begin, end - begin + 1);
    } else {
        int keyi = PartSort(arr, begin, end);   // 算出枢轴值
        QuickSort(arr, begin, keyi - 1);            // 对低子表递归排序
        QuickSort(arr, keyi + 1, end);            // 对高子表递归排序
    }
}
  • 双指针法
// 插入排序
void InsertSort(int *arr, int size) {
    for (int i = 1; i < size; i++) {
        int num = arr[i];
        int end = i - 1;
        for (; end >= 0; end--) {
            if (arr[end] > num) {
                arr[end + 1] = arr[end];
            } else {
                break;
            }
        }
        arr[end + 1] = num;
    }
}

// 算法 数值交换
void Swap(void *A, void *B, int size) {
    while (size--) {
        char tmp = *(char *)A;
        *(char *)A = *(char *)B;
        *(char *)B = tmp;
        A = (char *)A + 1;
        B = (char *)B + 1;
    }
}

// 取中间值
int GetMidIndex(int *arr, int left, int right) {
    int mid = left + (right - left) / 2;    // 防止相加溢出
    if ((arr[mid] <= arr[left] && arr[left] <= arr[right]) || (arr[mid] >= arr[left] && arr[left] >= arr[right])) {
        return left;
    } else if ((arr[mid] <= arr[right] && arr[right] <= arr[left]) || (arr[mid] >= arr[right] && arr[right] >= arr[left])) {
        return right;
    } else {
        return mid;
    }
}

// 单趟排序
int PartSort(int *arr, int left, int right) {
    // 三数取中
    int mid = GetMidIndex(arr, left, right);
    Swap(&arr[left], &arr[mid], sizeof(int));

    int keyi = left;
    int prev = left;
    int curr = prev + 1;

    while (curr <= right) {
        // 找小
        if (arr[curr] < arr[keyi] && ++prev != curr) {
            Swap(&arr[curr], &arr[prev], sizeof(int));
        }
        curr++;
    }

    Swap(&arr[keyi], &arr[prev], sizeof(int));

    return prev;
}

// 快速排序
void QuickSort(int *arr, int begin, int end) {
    if (begin >= end) {
        return;
    }
    if (end - begin <= 8) {
        InsertSort(arr + begin, end - begin + 1);
    } else {
        int keyi = PartSort(arr, begin, end);   // 算出枢轴值
        QuickSort(arr, begin, keyi - 1);            // 对低子表递归排序
        QuickSort(arr, keyi + 1, end);            // 对高子表递归排序
    }
}

4.特性

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N * log2N)
  3. 空间复杂度：O(log2N)
  4. 稳定性：不稳定

● 归并排序

1.思想

归并排序: 归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

2.图解

在这里插入图片描述

3.代码

void _MergeSort(int *arr, int left, int right, int *mat) {
    // 停止条件
    if (left >= right) {
        return;
    }

    // 递归到最深处
    int mid = (left + right) >> 1;      //除2
    _MergeSort(arr, left, mid, mat);
    _MergeSort(arr, mid + 1, right, mat);

    // 创建临时变量
    int begin1 = left, end1 = mid;          // 左半部分
    int begin2 = mid + 1, end2 = right;     // 右半部分

    // 谁小拷贝进新数组
    int i = left;
    while (begin1 <= end1 && begin2 <= end2) {
        mat[i++] = arr[begin1] < arr[begin2] ? arr[begin1++] : arr[begin2++];
    }

    // 将剩余部分拷贝进新数组
    while (begin1 <= end1) {
        mat[i++] = arr[begin1++];
    }
    while (begin2 <= end2) {
        mat[i++] = arr[begin2++];
    }

    // 归并完成后拷贝回原数组
    for (int j = left; j <= right; j++) {
        arr[j] = mat[j];
    }
}

void MergeSort(int *arr, int n) {
    int *mat = (int *)malloc(n * sizeof(int));
    if (mat == NULL) {
        perror("mat malloc fail:");
    }
    // 调用递归
    _MergeSort(arr, 0, n - 1, mat);

    free(mat);
}

4.特性

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N * log2N)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定

● 计数排序

1.思想

计数排序: 计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。

  1. 统计相同元素出现次数
  2. 根据统计的结果将序列回收到原来的序列中

2.图解

在这里插入图片描述

3.代码

void CountSort(int *arr, int n) {
    // 选取最大的最小值
    int max = arr[0], min = arr[0];
    for (int i = 0; i < n; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    // 计算范围
    int range = max - min + 1;
    // 开辟空间
    int *count = (int *)malloc(range * sizeof(int));
    memset(count, 0, range * sizeof(int));
    // 统计数字个数
    for (int i = 0; i < n; i++) {
        count[arr[i] - min]++;
    }
    // 按顺序放入
    int i = 0;
    for (int j = 0; j < range; j++) {
        // 按数字个数放入
        while (count[j]--) {
            arr[i++] = j + min;
        }
    }
}

4.特性

  1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
  2. 时间复杂度：O(MAX(N,范围))
  3. 空间复杂度：O(范围)
  4. 稳定性：稳定

三、排序算法比较

请添加图片描述

排序算法平均情况最好情况最坏情况辅助空间稳定性
冒泡排序O(N2)O(N)O(N2)O(1)稳定
选择排序O(N2)O(N2)O(N2)O(1)不稳定
插入排序O(N2)O(N2)O(N2)O(1)稳定
希尔排序O(N * log2N)~O(N2)O(N1.3)O(N2)O(1)不稳定
堆排序O(N * log2N)O(N * log2N)O(N * log2N)O(1)不稳定
归并排序O(N * log2N)O(N * log2N)O(N * log2N)O(N)稳定
快速排序O(N * log2N)O(N * log2N)O(N2)O(log2N)~O(N2)不稳定

四、总结

排序算法是解决实际问题时极其常用的算法，是非常重要的解决问题的方式。排序算法函数的复现，有利于更好的学习排序的思想，有利于开阔视野，学习前辈的智慧结晶。对我们后续解决实际问题也会有很大帮助。

数据结构—排序
AI_ELF的博客
09-10 2179
排序方法平均情况最好情况最坏情况辅助空间稳定性冒泡排序O(N2N^2N2O(N)O(N2N^2N2O(1)稳定简单选择排序O(N2N^2N2O(N2N^2N2O(N2N^2N2O(1)不稳定直接插入排序O(N2N^2N2O(N)O(N2N^2N2O(1)稳定希尔排序O(NlogNlogNlogN∽\backsim∽O(N2N^2N2O(N1.3N^{1.3}N1.3O(N2N^2N2O(1)
十种常见排序算法的思想、应用场景、C++代码实现及时间效率直观对比
Hairy_Monsters的博客
05-01 7656
前言： 写在这篇博客前面，最近发现自己做事学东西远没有以前的踏实，往往学过之后很快就忘记，包括基础的排序算法，虽然看过几遍，但是却没有真正掌握，到了突然需要自己抛开书本手写的时候，发现自己对它们其实挺陌生的。所以希望借写这篇博客的机会，让自己好好复习一下基本的排序算法，也希望自己从现在开始能做到学东西像之前一样踏实。 这篇博客中包含的排序算法主要有：冒泡排序，插入排序，希尔排序，选择排...
【数据结构】七大排序算法（超详细）
m0_59176913的博客
06-10 3934
本文详细介绍了数据结构中的七大排序算法
关于八大排序算法这一篇已经足够【建议收藏】
qq_57770005的博客
06-07 1067
关于排序算法这一篇已经足够【建议收藏】前言排序1.有关于排序的概念2.常见排序算法的实现2.1插入排序2.1.1直接插入排序。2.1.2希尔排序2.2交换排序2.2.1冒泡排序欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowch
各种排序算法的使用场景
请叫我皮皮虾的博客
09-29 3117
排序使用场景： (1)若n较小(如n≤50)，可采用直接插入或直接选择排序； 当记录规模较小时，直接插入排序较好； 否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。 (2)若文件初始状态基本有序(指正序)，则应选用直接插人或冒泡排序为宜； (3)若文件初始状态随机分布，则应选用快速排序为宜； (4)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或...
【数据结构】——八大排序（详解+图+代码详解）看完你会有一个全新认识
m0_74092462的博客
04-12 1903
排序在生活中是非常重要的，所以排序在数据结构中也占有很大的地位，相信大家可能被这些排序弄得比较混淆或者对某个排序原理没有弄清，相信看完本篇会对你有所帮助！排序的概念与应用排序概念排序：排序就是使一串数据，按某个或者某些关键字的大小，递减或者递增排列起来的操作稳定性：在排序的过程中，可能存在两个或者以上的关键字相等的记录，排序的结果可能会不一样，这里就分成了稳定和不稳定。
数据结构与算法——八大排序算法及总结（JAVA实现，图文详解）
nswdiphone6的博客
02-22 817
这里写目录标题一级目录二级目录三级目录排序算法1.冒泡排序2.选择排序3.插入排序4.希尔排序5.快速排序6.归并排序7.基数排列**8.堆排序**八大排序算法总结 一级目录 二级目录 三级目录 排序算法 1.冒泡排序 ​ 比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 ​ 针对所有的元素重复以上的步骤，除了最后一个，即需要进行length-1次。 ​ 第一次是对n个数进行n-1次
数据结构经典排序算法——python（详细汇总）
perfect_code_hzy的博客
08-28 2057
python算法学习笔记前言一、冒泡排序1.1 算法步骤1.2 图解1.3 排序效率1.4 Python代码实现二、选择排序2.1 算法步骤2.2 图解2.3 Python代码实现三、插入排序3.1 算法步骤3.2 图解3.3 排序效率3.4 Python代码实现四、希尔排序4.1 算法步骤4.2 图解4.3 排序效率4.4 Python代码实现五、归并排序5.1 算法步骤5.2 图解5.3 Python代码实现六、快速排序6.1 算法步骤6.2 图解6.3 Python代码实现七、堆排序7.1 算法步骤7
数据结构 排序 （图解+C语言）
鸿雁丨红豆灬自学计算机学习记录
05-20 1337
排序
图解精讲快速排序（C语言实现）
最新发布
Darling912的博客
09-18 1166
首先我们可能对于这种的分而治之的思想是很不习惯的，我们刚刚去接触这个快速排序这个算法的时候，我们可能是不太可以去真正的理解这种的思想的，而且我们在之前所学的比如说冒泡排序，插入排序，选择排序这样的相对简单的排序算法，这个快速排序我们是比较难入门的，但是没关系，听我细细道来！，直到最后子问题可以简单的直接求解，原问题的解即「 子问题 」的解的合并。「 快速排序 」是利用了「 分而治之 」的思想，进行递归计算的排序算法，效率在众多排序算法中的佼佼者，一般也会出现在各种「数据结构」的教科书上。
常用的排序算法及其适用场景
LLL_foever的博客
04-15 3268
1.介绍 常用的排序算法主要有冒泡排序，选择排序，插入排序，希尔排序，堆排序，归并排序，快速排序，桶排序等。 2.稳定性 稳定的排序算法：冒泡排序，插入排序； 不稳定的排序算法：选择排序，希尔排序，堆排序，归并排序，快速排序。 3.排序算法的实现 3.1冒泡排序 冒泡排序的时间复杂度为O(n*n)，空间复杂度为O(1)，在数据有序的时候时间复杂度可以达到O(n)。 适用的情...
最新十大排序算法详细讲解，以及各种应用场景
热门推荐
小猪向前冲
07-31 1万+
十大排序算法汇总 比较和非比较的区别 常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。 在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)...
常见排序算法及其使用场景
java领域分享
09-01 3355
【代码】常见排序算法及其使用场景。
数据结构——排序
2301_78089774的博客
08-20 193
1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用2. 时间复杂度：O(N^2)3. 空间复杂度：O(1)4. 稳定性：不稳定。
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

十里坡小白

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

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

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

打赏作者

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

抵扣说明：

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

余额充值