八大排序算法汇总（C语言实现）

本专栏内容为：八大排序汇总 通过本专栏的深入学习，你可以了解并掌握八大排序以及相关的排序算法。

💓博主csdn个人主页：小小unicorn
⏩专栏分类：八大排序汇总
🚚代码仓库：小小unicorn的代码仓库🚚
🌹🌹🌹关注我带你学习编程知识

目录

  • 直接插入排序
  • 希尔排序
  • 选择排序
  • 堆排序
  • 冒泡排序
  • 快速排序
    • 递归实现
      • Hoare版本
      • 挖坑法
      • 前后指针法
    • 非递归实现
    • 快速排序的两个优化版本
      • 三数取中
      • 小区间优化
  • 归并排序
    • 递归实现
    • 非递归实现
  • 计数排序
  • 排序算法复杂度及稳定性分析

直接插入排序

动图演示：
在这里插入图片描述
插入排序，又叫直接插入排序。实际中，我们玩扑克牌的时候，就用了插入排序的思想。

基本思想：
 在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个元素有序。按照此法对所有元素进行插入，直到整个序列有序。

注意：
我们并不能确定待排元素中究竟哪一部分是有序的，所以我们一开始只能认为第一个元素是有序的，依次将其后面的元素插入到这个有序序列中来，直到整个序列有序为止。

在这里插入图片描述
代码实现：

//插入排序
void InsertSort(int* a, int n)
{int i = 0;//整体：for (i = 0; i < n - 1; i++){//单趟：//[0,end]有序，把end+1的位置的插入到前序序列//控制[0,end+1]有序int end = i;int tmp = a[end + 1];//待插入的元素while (end >= 0){if (tmp < a[end])//还需继续比较{a[end + 1] = a[end];}else//找到应插入的位置{break;}--end;}a[end + 1] = tmp;//代码执行到此位置有两种情况://1.待插入元素找到应插入位置（break跳出循环到此）。//2.待插入元素比当前有序序列中的所有元素都小（while循环结束后到此）。}
}

1.时间复杂度：O (N2)
2.空间复杂度：O (1)
3.稳定性：稳定

希尔排序

动图演示：
在这里插入图片描述.希尔排序是按其设计者希尔的名字命名的，该算法由希尔1959年公布。希尔对普通插入排序的时间复杂度进行分析，得出了以下结论：
 1.普通插入排序的时间复杂度最坏情况下为O(N2)，此时待排序列为逆序，或者说接近逆序。
 2.普通插入排序的时间复杂度最好情况下为O(N)，此时待排序列为升序，或者说接近升序。
在这里插入图片描述

于是希尔就思考：若是能先将待排序列进行一次预排序，使待排序列接近有序（接近我们想要的顺序），然后再对该序列进行一次直接插入排序。因为此时直接插入排序的时间复杂度为O(N)，那么只要控制预排序阶段的时间复杂度不超过O(N2)，那么整体的时间复杂度就比直接插入排序的时间复杂度低了。

希尔排序，又称缩小增量法。其基本思想是：
 
 1.先选定一个小于N的整数gap作为第一增量，然后将所有距离为gap的元素分在同一组，并对每一组的元素进行直接插入排序。然后再取一个比第一增量小的整数作为第二增量，重复上述操作…
 2.当增量的大小减到1时，就相当于整个序列被分到一组，进行一次直接插入排序，排序完成。

思考一下：为什么要让gap由大到小呢？
回答：gap越大，数据挪动得越快；gap越小，数据挪动得越慢。

前期让gap较大，可以让数据更快得移动到自己对应的位置附近，减少挪动次数。

注意：一般情况下，我们取序列的一半作为增量，然后依次减半，直到增量为1（也可自己设置）。

举个例子分析一下：
 现在我们用希尔排序对该序列进行排序。
 在这里插入图片描述
 我们用序列长度的一半作为第一次排序时gap的值，此时相隔距离为5的元素被分为一组（共分了5组，每组有2个元素），然后分别对每一组进行直接插入排序。
 在这里插入图片描述
 gap的值折半，此时相隔距离为2的元素被分为一组（共分了2组，每组有5个元素），然后再分别对每一组进行直接插入排序。
 在这里插入图片描述
 gap的值再次折半，此时gap减为1，即整个序列被分为一组，进行一次直接插入排序。
 在这里插入图片描述
 该例子中，前两趟就是希尔排序的预排序，而最后一趟实现的是希尔排序的直接插入排序。

代码实现：

void ShellSort(int* a, int n)
{int gap = n;while (gap > 1){//gap = gap / 2;gap = gap / 3 + 1;for (int i = 0; i < n - gap; ++i){int end = i;int tmp = a[end + gap];while (end >= 0){if (tmp < a[end]){a[end + gap] = a[end];end -= gap;}else{break;}}a[end + gap] = tmp;}}
}

希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书籍中给出的希尔排序的时间复杂度都不固定。

在这里插入图片描述
在这里插入图片描述
因为咱们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O（N1.25）或者O（1.6*N1.25）来进行计算。
稳定性：不稳定

选择排序

动图演示：
在这里插入图片描述
选择排序，即每次从待排序列中选出一个最小值，然后放在序列的起始位置，直到全部待排数据排完即可。

//选择排序(一次选一个数)
void SelectSort(int* a, int n)
{int i = 0;for (i = 0; i < n; i++)//i代表参与该趟选择排序的第一个元素的下标{int start = i;int min = start;//记录最小元素的下标while (start < n){if (a[start] < a[min])min = start;//最小值的下标更新start++;}Swap(&a[i], &a[min]);//最小值与参与该趟选择排序的第一个元素交换位置}
}

我们可以一趟选出两个值，一个最大值一个最小值，然后将其放在序列开头和末尾，这样可以使选择排序的效率快一倍。

代码实现：

//选择排序(一次选两个数)
void SelectSort(int* a, int n)
{int left = 0;//记录参与该趟选择排序的第一个元素的下标int right = n - 1;//记录参与该趟选择排序的最后一个元素的下标while (left < right){int minIndex = left;//记录最小元素的下标int maxIndex = left;//记录最大元素的下标int i = 0;//找出最大值及最小值的下标for (i = left; i <= right; i++){if (a[i] < a[minIndex])minIndex = i;if (a[i] > a[maxIndex])maxIndex = i;}//将最大值和最小值放在序列开头和末尾Swap(&a[minIndex], &a[left]);if (left == maxIndex){maxIndex = minIndex;//防止最大值位于序列开头，被最小值交换}Swap(&a[maxIndex], &a[right]);left++;right--;}
}
  1. 时间复杂度：O(N^2)
  2. 空间复杂度：O(1)
  3. 稳定性：不稳定

堆排序

动图演示：
在这里插入图片描述
在之前的文章：堆的介绍中，我们知道堆的介绍，如何建堆，以及堆的向上，向下调整法的实现，而堆排序就是依靠建堆，通过堆的方式的进行排序。至于堆的建立与实现，本文章就不过多叙述了，详情请点击堆的介绍与实现查看。

堆建好后，如何进行堆排序，步骤如下：
 1、将堆顶数据与堆的最后一个数据交换，然后对根位置进行一次堆的向下调整，但是调整时被交换到最后的那个最大的数不参与向下调整。
 2、完成步骤1后，这棵树除最后一个数之外，其余数又成一个大堆，然后又将堆顶数据与堆的最后一个数据交换，这样一来，第二大的数就被放到了倒数第二个位置上，然后该数又不参与堆的向下调整…反复执行下去，直到堆中只有一个数据时便结束。此时该序列就是一个升序。

代码实现：

//向下调整法：
void AdjustDown(int* a, int n, int parent)
{int child = parent * 2 + 1;while (child < n){// 找出小的那个孩子if (child + 1 < n && a[child + 1] > a[child]){++child;}if (a[child] > a[parent]){Swap(&a[child], &a[parent]);// 继续往下调整parent = child;child = parent * 2 + 1;}else{break;}}
}/堆排序
void HeapSort(int* a, int n)
{// 向下调整建堆// O(N)for (int i = (n - 1 - 1) / 2; i >= 0; i--){AdjustDown(a, n, i);}// O(N*logN)int end = n - 1;while (end > 0){Swap(&a[0], &a[end]);AdjustDown(a, end, 0);--end;}
}
  1. 时间复杂度：O(N*logN)
  2. 空间复杂度：O(1)
  3. 稳定性：不稳定

冒泡排序

动图演示：
在这里插入图片描述
冒泡排序(Bubble Sort)：是一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

void BubbleSort(int* a, int n)
{for (size_t j = 0; j < n; j++){int exchange = 0;for (size_t i = 1; i < n - j; i++){if (a[i - 1] > a[i]){Swap(&a[i - 1], &a[i]);exchange = 1;}}if (exchange == 0){break;}}
}
  1. 时间复杂度：O(N^2)
  2. 空间复杂度：O(1)
  3. 稳定性：稳定

快速排序

递归实现

Hoare版本

动图演示：
在这里插入图片描述
Hoare版本的单趟排序的基本步骤如下：
 1、选出一个key，一般是最左边或是最右边的。
 2、定义一个L和一个R，L从左向右走，R从右向左走。（需要注意的是：若选择最左边的数据作为key，则需要R先走；若选择最右边的数据作为key，则需要L先走）。
 3、在走的过程中，若R遇到小于key的数，则停下，L开始走，直到L遇到一个大于key的数时，将L和R的内容交换，R再次开始走，如此进行下去，直到L和R最终相遇，此时将相遇点的内容与key交换即可。（选取最左边的值作为key）

经过一次单趟排序，最终使得key左边的数据全部都小于key，key右边的数据全部都大于key。

然后我们在将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作，因为这种序列可以认为是有序的。

单趟排序代码实现：

// Hoare版本
int PartSort1(int* a, int left, int right)
{//三数取中/*int midi = GetMidi(a, left, right);Swap(&a[left], &a[midi]);*/int keyi = left;while (left < right){// 找小while (left < right && a[right] >= a[keyi]){--right;}// 找大while (left < right && a[left] <= a[keyi]){++left;}Swap(&a[left], &a[right]);}Swap(&a[keyi], &a[left]);return left;
}

整体递归实现：

void QuickSort(int* a, int begin, int end)
{if (begin >= end)return;int keyi = PartSort1(a, begin, end);// [begin, keyi-1] keyi [keyi+1, end]QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);
}

挖坑法

动图演示：
在这里插入图片描述
挖坑法的单趟排序的基本步骤如下：
 1、选出一个数据（一般是最左边或是最右边的）存放在key变量中，在该数据位置形成一个坑。
 2、还是定义一个L和一个R，L从左向右走，R从右向左走。（若在最左边挖坑，则需要R先走；若在最右边挖坑，则需要L先走）。
 3、在走的过程中，若R遇到小于key的数，则将该数抛入坑位，并在此处形成一个坑位，这时L再向后走，若遇到大于key的数，则将其抛入坑位，又形成一个坑位，如此循环下去，直到最终L和R相遇，这时将key抛入坑位即可。（选取最左边的作为坑位）

经过一次单趟排序，最终也使得key左边的数据全部都小于key，key右边的数据全部都大于key。

然后也是将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作。

单趟排序代码实现：

// 挖坑法
int PartSort2(int* a, int left, int right)
{//三数取中优化/*int midi = GetMidi(a, left, right);Swap(&a[left], &a[midi]);*/int key = a[left];// 保存key值以后，左边形成第一个坑int hole = left;while (left < right){// 右边先走，找小，填到左边的坑，右边形成新的坑位while (left < right && a[right] >= key){--right;}a[hole] = a[right];hole = right;// 左边再走，找大，填到右边的坑，左边形成新的坑位while (left < right && a[left] <= key){++left;}a[hole] = a[left];hole = left;}a[hole] = key;return hole;
}

整体递归实现：

void QuickSort(int* a, int begin, int end)
{if (begin >= end)return;int keyi = PartSort2(a, begin, end);// [begin, keyi-1] keyi [keyi+1, end]QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);
}

前后指针法

动图演示：
在这里插入图片描述
前后指针法的单趟排序的基本步骤如下：
 1、选出一个key，一般是最左边或是最右边的。
 2、起始时，prev指针指向序列开头，cur指针指向prev+1。
 3、若cur指向的内容小于key，则prev先向后移动一位，然后交换prev和cur指针指向的内容，然后cur指针++；若cur指向的内容大于key，则cur指针直接++。如此进行下去，直到cur指针越界，此时将key和prev指针指向的内容交换即可。

经过一次单趟排序，最终也能使得key左边的数据全部都小于key，key右边的数据全部都大于key。
然后也还是将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作。

单趟排序代码实现：

// 前后指针
int PartSort3(int* a, int left, int right)
{//三数取中/*int midi = GetMidi(a, left, right);Swap(&a[left], &a[midi]);*/int prev = left;int cur = prev + 1;int keyi = left;while (cur <= right){if (a[cur] < a[keyi] && ++prev != cur){Swap(&a[prev], &a[cur]);}++cur;}Swap(&a[prev], &a[keyi]);return prev;
}

整体递归实现：

void QuickSort(int* a, int begin, int end)
{if (begin >= end)return;int keyi = PartSort3(a, begin, end);// [begin, keyi-1] keyi [keyi+1, end]QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);
}
  1. 时间复杂度：O(N*logN)
  2. 空间复杂度：O(logN)
  3. 稳定性：不稳定

非递归实现

快速排序的非递归算法基本思路：
 1、先将待排序列的第一个元素的下标和最后一个元素的下标入栈。
 2、当栈不为空时，读取栈中的信息（一次读取两个：一个是L，另一个是R），然后调用某一版本的单趟排序，排完后获得了key的下标，然后判断key的左序列和右序列是否还需要排序，若还需要排序，就将相应序列的L和R入栈；若不需排序了（序列只有一个元素或是不存在），就不需要将该序列的信息入栈。
 3、反复执行步骤2，直到栈为空为止。

在实现快排的非递归时，需要用到栈，所以，我们首先要进行栈的实现，代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>//#define N 10
//struct Stack
//{
//	int a[N];
//	int top;
//};typedef int STDataType;
typedef struct Stack
{STDataType* a;int top;int capacity;
}ST;void STInit(ST* ps)
{assert(ps);ps->a = NULL;ps->capacity = 0;ps->top = 0;
}void STDestroy(ST* ps)
{assert(ps);free(ps->a);ps->a = NULL;ps->top = ps->capacity = 0;
}void STPush(ST* ps, STDataType x)
{assert(ps);// 11:40if (ps->top == ps->capacity){int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);if (tmp == NULL){perror("realloc fail");exit(-1);}ps->a = tmp;ps->capacity = newCapacity;}ps->a[ps->top] = x;ps->top++;
}void STPop(ST* ps)
{assert(ps);// assert(ps->top > 0);--ps->top;
}STDataType STTop(ST* ps)
{assert(ps);// assert(ps->top > 0);return ps->a[ps->top - 1];
}int STSize(ST* ps)
{assert(ps);return ps->top;
}bool STEmpty(ST* ps)
{assert(ps);return ps->top == 0;
}

要是对栈的基本操作实现还有问题的，可以查看小编的文章：栈的介绍与实现

非递归快排完整代码如下：

//快排非递归实现：
void QuickSortNonR(int* a, int begin, int end)
{ST st;STInit(&st);STPush(&st, end);STPush(&st, begin);while (!STEmpty(&st)){int left = STTop(&st);STPop(&st);int right = STTop(&st);STPop(&st);int keyi = PartSort1(a, left, right);// [lefy,keyi-1] keyi [keyi+1, right]if (keyi + 1 < right){STPush(&st, right);STPush(&st, keyi + 1);}if (left < keyi - 1){STPush(&st, keyi - 1);STPush(&st, left);}}STDestroy(&st);
}

快速排序的两个优化版本

三数取中

快速排序的时间复杂度是O(NlogN)，是我们在理想情况下计算的结果。在理想情况下，我们每次进行完单趟排序后，key的左序列与右序列的长度都相同：
在这里插入图片描述
若每趟排序所选的key都正好是该序列的中间值，即单趟排序结束后key位于序列正中间，那么快速排序的时间复杂度就是O(NlogN)。

可是谁也不能保证每次选取的key都是正中间的那个数，当待排序列本就是一个有序的序列时，我们若是依然每次都选取最左边或是最右边的数作为key，那么快速排序的效率将达到最低：
在这里插入图片描述
可以看到，这种情况下，快速排序的时间复杂度退化为O(N2)。其实，对快速排序效率影响最大的就是选取的key，若选取的key越接近中间位置，则则效率越高。

为了避免这种极端情况的发生，于是出现了三数取中：
 
 三数取中，当中的三数指的是：最左边的数、最右边的数以及中间位置的数。三数取中就是取这三个数当中，值的大小居中的那个数作为该趟排序的key。这就确保了我们所选取的数不会是序列中的最大或是最小值了。

// 三数取中
int GetMidi(int* a, int left, int right)
{int mid = (left + right) / 2;// left mid rightif (a[left] < a[mid]){if (a[mid] < a[right]){return mid;}else if (a[left] > a[right])  // mid是最大值{return left;}else{return right;}}else // a[left] > a[mid]{if (a[mid] > a[right]){return mid;}else if (a[left] < a[right]) // mid是最小{return left;}else{return right;}}
}

注意：当大小居中的数不在序列的最左或是最右端时，我们不是就以居中数的位置作为key的位置，而是将key的值与最左端的值进行交换，这样key就还是位于最左端了，所写代码就无需改变，而只需在单趟排序代码开头加上以下两句代码即可：

	int midIndex = GetMidIndex(a, begin, end);//获取大小居中的数的下标Swap(&a[begin], &a[midIndex]);//将该数与序列最左端的数据交换//以下代码保持不变...

小区间优化

我们可以看到，就算是上面理想状态下的快速排序，也不能避免随着递归的深入，每一层的递归次数会以2倍的形式快速增长。
 为了减少递归树的最后几层递归，我们可以设置一个判断语句，当序列的长度小于某个数的时候就不再进行快速排序，转而使用其他种类的排序。小区间优化若是使用得当的话，会在一定程度上加快快速排序的效率，而且待排序列的长度越长，该效果越明显。

代码实现：

//小区间优化
void QuickSort1(int* a, int begin, int end)
{if (begin >= end)return;// 小区间优化，小区间不再递归分割排序，降低递归次数if ((end - begin + 1) > 10)//可以自行微调{//可调用快速排序的单趟排序三种中的任意一种//int keyi = PartSort1(a, begin, end);//int keyi = PartSort2(a, begin, end);int keyi = PartSort3(a, begin, end);// [begin, keyi-1] keyi [keyi+1, end]QuickSort1(a, begin, keyi - 1);QuickSort1(a, keyi + 1, end);}else{InsertSort(a + begin, end - begin + 1);}
}

归并排序

动图演示：
在这里插入图片描述
归并排序是采用分治法的一个非常典型的应用。其基本思想是：将已有序的子序合并，从而得到完全有序的序列，即先使每个子序有序，再使子序列段间有序。

那么如何得到有序的子序列呢？当序列分解到只有一个元素或是没有元素时，就可以认为是有序了，这时分解就结束了，开始合并：
在这里插入图片描述

递归实现

//归并排序（子函数）
void _MergeSort(int* a, int left, int right, int* tmp)
{if (left >= right)//归并结束条件：当只有一个数据或是序列不存在时，不需要再分解{return;}int mid = left + (right - left) / 2;//中间下标_MergeSort(a, left, mid, tmp);//对左序列进行归并_MergeSort(a, mid + 1, right, tmp);//对右序列进行归并int begin1 = left, end1 = mid;int begin2 = mid + 1, end2 = right;//将两段子区间进行归并，归并结果放在tmp中int i = left;while (begin1 <= end1&&begin2 <= end2){//将较小的数据优先放入tmpif (a[begin1] < a[begin2])tmp[i++] = a[begin1++];elsetmp[i++] = a[begin2++];}//当遍历完其中一个区间，将另一个区间剩余的数据直接放到tmp的后面while (begin1 <= end1)tmp[i++] = a[begin1++];while (begin2 <= end2)tmp[i++] = a[begin2++];//归并完后，拷贝回原数组int j = 0;for (j = left; j <= right; j++)a[j] = tmp[j];
}
//归并排序（主体函数）
void MergeSort(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int)*n);//申请一个与原数组大小相同的空间if (tmp == NULL){printf("malloc fail\n");exit(-1);}_MergeSort(a, 0, n - 1, tmp);//归并排序free(tmp);//释放空间
}

非递归实现

非递归算法并不需要借助栈来完成，我们只需要控制每次参与合并的元素个数即可，最终便能使序列变为有序：
在这里插入图片描述
当然，以上例子是一个待排序列长度比较特殊的例子，我们若是想写出一个广泛适用的程序，必定需要考虑到某些极端情况：
情况一：
 当最后一个小组进行合并时，第二个小区间存在，但是该区间元素个数不够gap个，这时我们需要在合并序列时，对第二个小区间的边界进行控制。

在这里插入图片描述
情况二：
 当最后一个小组进行合并时，第二个小区间不存在，此时便不需要对该小组进行合并。
在这里插入图片描述
情况三：
 当最后一个小组进行合并时，第二个小区间不存在，并且第一个小区间的元素个数不够gap个，此时也不需要对该小组进行合并。（可与情况二归为一类）
在这里插入图片描述

//归并排序（子函数）
void _MergeSortNonR(int* a, int* tmp, int begin1, int end1, int begin2, int end2)
{int j = begin1;//将两段子区间进行归并，归并结果放在tmp中int i = begin1;while (begin1 <= end1&&begin2 <= end2){//将较小的数据优先放入tmpif (a[begin1] < a[begin2])tmp[i++] = a[begin1++];elsetmp[i++] = a[begin2++];}//当遍历完其中一个区间，将另一个区间剩余的数据直接放到tmp的后面while (begin1 <= end1)tmp[i++] = a[begin1++];while (begin2 <= end2)tmp[i++] = a[begin2++];//归并完后，拷贝回原数组for (; j <= end2; j++)a[j] = tmp[j];
}
//归并排序（主体函数）
void MergeSortNonR(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int)*n);//申请一个与待排序列大小相同的空间，用于辅助合并序列if (tmp == NULL){printf("malloc fail\n");exit(-1);}int gap = 1;//需合并的子序列中元素的个数while (gap < n){int i = 0;for (i = 0; i < n; i += 2 * gap){int begin1 = i, end1 = i + gap - 1;int begin2 = i + gap, end2 = i + 2 * gap - 1;if (begin2 >= n)//最后一组的第二个小区间不存在或是第一个小区间不够gap个，此时不需要对该小组进行合并break;if (end2 >= n)//最后一组的第二个小区间不够gap个，则第二个小区间的后界变为数组的后界end2 = n - 1;_MergeSortNonR(a, tmp, begin1, end1, begin2, end2);//合并两个有序序列}gap = 2 * gap;//下一趟需合并的子序列中元素的个数翻倍}free(tmp);//释放空间
}
  1. 时间复杂度：O(N*logN)
  2. 空间复杂度：O(N)
  3. 稳定性：稳定

计数排序

计数排序，又叫非比较排序。顾名思义，该算法不是通过比较数据的大小来进行排序的，而是通过统计数组中相同元素出现的次数，然后通过统计的结果将序列回收到原来的序列中。

在这里插入图片描述
上列中的映射方法称为绝对映射，即arr数组中的元素是几就在count数组中下标为几的位置++，但这样会造成空间浪费。例如，我们要将数组：1020,1021,1018，进行排序，难道我们要开辟1022个整型空间吗？
 若是使用计数排序，我们应该使用相对映射，简单来说，数组中的最小值就相对于count数组中的0下标，数组中的最大值就相对于count数组中的最后一个下标。这样，对于数组：1020,1021,1018，我们就只需要开辟用于储存4个整型的空间大小了，此时count数组中下标为i的位置记录的实际上是1018+i这个数出现的次数。

总结：
 绝对映射：count数组中下标为i的位置记录的是arr数组中数字i出现的次数。
 相对映射：count数组中下标为i的位置记录的是arr数组中数字min+i出现的次数。

注意：计数排序只适用于数据范围较集中的序列的排序，若待排序列的数据较分散，则会造成空间浪费，并且计数排序只适用于整型排序，不适用与浮点型排序。

代码如下：

//计数排序
void CountSort(int* a, int n)
{int min = a[0];//记录数组中的最小值int max = a[0];//记录数组中的最大值for (int i = 0; i < n; i++){if (a[i] < min)min = a[i];if (a[i] > max)max = a[i];}int range = max - min + 1;//min和max之间的自然数个数（包括min和max本身）int* count = (int*)calloc(range, sizeof(int));//开辟可储存range个整型的内存空间，并将内存空间置0if (count == NULL){printf("malloc fail\n");exit(-1);}//统计相同元素出现次数（相对映射）for (int i = 0; i < n; i++){count[a[i] - min]++;}int i = 0;//根据统计结果将序列回收到原来的序列中for (int j = 0; j < range; j++){while (count[j]--){a[i++] = j + min;}}free(count);//释放空间
}
  1. 时间复杂度：O(MAX(N,range))
  2. 空间复杂度：O(range)

排序算法复杂度及稳定性分析

在这里插入图片描述
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/125600.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

智慧公厕：将科技融入日常生活的创新之举

智慧公厕：将科技融入日常生活的创新之举

智慧公厕是当今社会中一项备受关注的创新项目。通过将科技融入公厕设计和管理中&#xff0c;这些公厕不仅能够提供更便利、更卫生的使用体验&#xff0c;还能够极大地提升城市形象和居民生活质量。本文将以智慧公厕领先厂家广州中期科技有限公司&#xff0c;大量的精品案例项目…
阅读更多...
React项目部署 - Nginx配置

React项目部署 - Nginx配置

写在前面&#xff1a;博主是一只经过实战开发历练后投身培训事业的“小山猪”&#xff0c;昵称取自动画片《狮子王》中的“彭彭”&#xff0c;总是以乐观、积极的心态对待周边的事物。本人的技术路线从Java全栈工程师一路奔向大数据开发、数据挖掘领域&#xff0c;如今终有小成…
阅读更多...
Ubuntu无法引导启动的修复

Ubuntu无法引导启动的修复

TLDR&#xff1a;使用Boot-Repair工具。 Boot-Repair Boot-Repair是一个简单的工具&#xff0c;用于修复您在Ubuntu中可能遇到的常见启动问题&#xff0c;例如在安装Windows或其他Linux发行版后无法启动Ubuntu时&#xff0c;或者在安装Ubuntu后无法启动Windows时&#xff0c;…
阅读更多...
Postman使用实例

Postman使用实例

Postman使用实例 实体类Emp package com.example.springboot_postman.pojo;import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor;import javax.persistence.*; import j…
阅读更多...
C++设计模式-原型（Prototype）

C++设计模式-原型（Prototype）

目录 C设计模式-原型&#xff08;Prototype&#xff09; 一、意图 二、适用性 三、结构 四、参与者 五、代码 C设计模式-原型&#xff08;Prototype&#xff09; 一、意图 用原型实例指定创建对象的种类&#xff0c;并且通过拷贝这些原型创建新的对象。 二、适用性 当…
阅读更多...
012-第二代硬件选型

012-第二代硬件选型

第二代硬件选型 文章目录 第二代硬件选型项目介绍重新换平台缘由X86 && Arm 架构切换 ARM Linux 硬件选型系统确定Qt 版本确定总结一下 关键字&#xff1a; Qt、 Qml、 Arm、 X86、 linux 项目介绍 欢迎来到我们的 QML & C 项目&#xff01;这个项目结合了 QM…
阅读更多...
IntelliJ IDEA配置Cplex12.6.3详细步骤

IntelliJ IDEA配置Cplex12.6.3详细步骤

Cplex12.6.3版IntelliJ IDEA配置详细步骤 一、Cplex12.6.3版下载地址二、Cplex安装步骤三、IDEA配置CPLEX3.1 添加CPLEX安装目录的cplex.jar包到项目文件中3.2 将CPLEX的x64_win64文件夹添加到IDEA的VM options中 四、检查IDEA中Cplex是否安装成功卸载Cplex 一、Cplex12.6.3版下…
阅读更多...
Seata 源码篇之AT模式启动流程 - 下 - 04

Seata 源码篇之AT模式启动流程 - 下 - 04

Seata 源码篇之AT模式启动流程 - 下 - 04 全局事务提交分支事务全局提交全局事务回滚分支事务全局回滚小结 本系列文章: Seata 源码篇之核心思想 - 01Seata 源码篇之AT模式启动流程 - 上 - 02Seata 源码篇之AT模式启动流程 - 中 - 03 上一篇文章&#xff0c;我们看了Seata AT…
阅读更多...
前端JavaScript入门到精通，javascript核心进阶ES6语法、API、js高级等基础知识和实战 —— Web APIs（四）

前端JavaScript入门到精通，javascript核心进阶ES6语法、API、js高级等基础知识和实战 —— Web APIs（四）

思维导图 一、日期对象 1.1 实例化 实例化&#xff0c;默认得到当前时间&#xff0c;也可以指定时间 1.2 日期对象方法 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible&q…
阅读更多...
GPX可视化工具 GPX航迹预览工具

GPX可视化工具 GPX航迹预览工具

背景 当我们收到别人分享的航迹文档&#xff0c;即gpx文档时&#xff0c;如何快速的进行浏览呢&#xff1f;我们可以使用GIS软件来打开gpx文档并显示gpx中所记录的航迹&#xff0c;例如常用的GIS软件有googleEarth&#xff0c; Basecamp&#xff0c; GPXsee&#xff0c; GPX E…
阅读更多...
ffmpeg之去除视频水印

ffmpeg之去除视频水印

ffmpeg去除水印使用delogo视频滤镜。 delogo参数: x,y,w,h分别表示logo区域的左上角位置及宽度和高度&#xff1b; show:0表示不显示logo区域&#xff0c;1表示显示logo区域。 执行下面的命令&#xff1a; ffmpeg -i 1.mp4 -vf delogox300:y10:w80:h30:show0 out.mp4 效果…
阅读更多...
华为云云耀云服务器L实例评测｜基于canal缓存自动更新流程 SpringBoot项目应用案例和源码

华为云云耀云服务器L实例评测｜基于canal缓存自动更新流程 SpringBoot项目应用案例和源码

前言 最近华为云云耀云服务器L实例上新&#xff0c;也搞了一台来玩&#xff0c;期间遇到各种问题&#xff0c;在解决问题的过程中学到不少和运维相关的知识。 在之前的博客中&#xff0c;介绍过canal的安装和配置&#xff0c;参考博客 拉取创建canal镜像配置相关参数 & …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023