八大排序之——计数排序全方位剖析！(小白也能轻松看懂！)

微软技术分享

优质创作者: 编程框架技术领域

领域专家: 操作系统技术领域

2025-01-23 20:42:59

1. 计数排序的思想动图

2. 从思想到代码的实现

>1.创建临时数组

我们先创建一个临时的数组tmp并且该数组的最大下标为原数组中元素的最大值（里面的元素初始化为0）

    //先遍历原数组找到最大值
    int max = a[0];
    for (int i = 1; i < n; i++)
    {
        if (max < a[i])
        {
            max = a[i];
        }
    }
    //动态内存开辟max+1个int空间并初始化为0用calloc
    int* tmp = (int)calloc(max+1, sizeof(int));
    if (tmp == NULL)
    {
        perror("calloc fail!\n");
        return;
    }

>2.统计次数

然后遍历一遍原数组，原数组中出现哪个元素就在tmp数组中与该元素数值相同的下标对应的地方进行加加操作来记录该元素出现的次数。

    //统计次数
    for (int i = 0; i < n; i++)
    {
        tmp[a[i]]++;
    }

>3.排序

最后我们再进行排序，记住tmp的下标对应原数组可能出现的元素，而里面的值对应该元素出现的次数，如果为0就说明该元素在原数组不存在。遍历tmp数组，将对应的下标覆盖原数组即可完成排序。

//排序
int j = 0;
for (int i = 0; i < max + 1; i++)//第一层循环遍历tmp数组
{
    while (tmp[i]--)//对应元素出现的次数
    {
        a[j++] = i;//tmp的下标对应的就是原数组可能出现的元素
    }
}
//释放资源，避免内存泄漏
free(tmp);
tmp = NULL;

>4.简单版本

好现在简单的计数排序就已经完成了

完整代码：

void CountSort(int* a,int n)
{
    //先遍历原数组找到最大值
    int max = a[0];
    for (int i = 1; i < n; i++)
    {
        if (max < a[i])
        {
            max = a[i];
        }
    }
    //动态内存开辟max+1个int空间并初始化为0用calloc
    int* tmp = (int*)calloc(max+1, sizeof(int));
    if (tmp == NULL)
    {
        perror("calloc fail!\n");
        return;
    }
    //统计次数
    for (int i = 0; i < n; i++)
    {
        tmp[a[i]]++;
    }
    //排序
    int j = 0;
    for (int i = 0; i < max + 1; i++)//第一层循环遍历tmp数组
    {
        while (tmp[i]--)//对应元素出现的次数
        {
            a[j++] = i;//tmp的下标对应的就是原数组可能出现的元素
        }
    }
    //释放资源，避免内存泄漏
    free(tmp);
    tmp = NULL;
}

3. 是否可以优化呢~

思考一下，如果我们的数据是这样的呢，如果还像之前那样开辟空间，是否会有大量的空间浪费呢？遍历的次数增大，是否有性能的降低呢~

所以，我们就可以这样取tmp的范围：

优化后代码：

//先遍历原数组找到最大值
int max = a[0];
int min = a[0];
for (int i = 1; i < n; i++)
{
    if (max < a[i])
    {
        max = a[i];
    }
    if (min > a[i])
    {
        min= a[i];
    }
}
int range = max - min + 1;
//动态内存开辟max+1个int空间并初始化为0用calloc
int* tmp = (int*)calloc(range, sizeof(int));
if (tmp == NULL)
{
    perror("calloc fail!\n");
    return;
}

关于下标与元素对应的问题，我们就可以采用相对映射的方法来解决（优化后代码）

优化后的完整代码：

void CountSort(int* a,int n)
{
    //先遍历原数组找到最大值
    int max = a[0];
    int min = a[0];
    for (int i = 1; i < n; i++)
    {
        if (max < a[i])
        {
            max = a[i];
        }
        if (min > a[i])
        {
            min= a[i];
        }
    }
    int range = max - min + 1;
    //动态内存开辟max+1个int空间并初始化为0用calloc
    int* tmp = (int*)calloc(range, sizeof(int));
    if (tmp == NULL)
    {
        perror("calloc fail!\n");
        return;
    }
    //统计次数
    for (int i = 0; i < n; i++)
    {
        tmp[a[i]-min]++;
    }
    //排序
    int j = 0;
    for (int i = 0; i < range; i++)//第一层循环遍历tmp数组
    {
        while (tmp[i]--)//对应元素出现的次数
        {
            a[j++] = i+min;//tmp的下标对应的就是原数组可能出现的元素
        }
    }
    //释放资源，避免内存泄漏
    free(tmp);
    tmp = NULL;
}