计数排序及其改进 C++代码实现与分析 恋上数据结构笔记

最新推荐文章于 2021-11-24 23:48:56 发布
最新推荐文章于 2021-11-24 23:48:56 发布
阅读量947 收藏 2
点赞数
分类专栏： 算法 文章标签： 数据结构 c++ 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SuSA_/article/details/121354723
版权

文章目录

复习梗概

  1. 基础算法思想？
  2. 两种改进的思路？重点在于最终版本思想
  3. 最终版本是如何做到稳定的？
  4. 三个数组（array，counts，temp）彼此间的索引和元素的对应关系？

算法思想

基础思想

  1. 计数排序适合对在一定范围内的整数进行排序
  2. 先找到排序数组的最大值，创建一个最大索引是该最大值的计数数组，初始值全部为0，然后对排序数组进行计数，若元素i出现了一次，就在计数数组的对应i索引处元素+1，全部计数后，只要按照计数数组的索引（原排序数组的元素）和对应的元素（原排序数组元素出现的次数）按顺序输出索引和对应的元素（即输出原元素和其出现的次数）即可
    图片来自网课恋上数据结构与算法，腾讯课堂
    在这里插入图片描述

改进空间复杂度，改进不能对负数进行排序问题

  1. 但是如果按照上述实现，会造成三个问题：1.不是稳定排序 2.及其浪费内存空间，前面0到最小值部分都用不上 3.无法对负整数进行排序，因为计数数组索引只能是正数
  2. 初步改进计数排序：同时查找排序数组的最大值和最小值（max and min），开辟空间为max-min+1的容量的数组，此时排序元素与计数数组的索引的对应关系：计数索引+min，即为原排序元素
  3. 如下图，为counts数组打印结果，注意索引以及经过+min处理，代表原排序元素
    在这里插入图片描述

改进稳定性

  1. 即使经过上面的改进依然不能做到稳定的排序，是因为我们按照 计数数组 的索引与次数 输出排序数组，无论如何都做不到稳定，因为两个相同的元素在 计数数组 的索引中是体现不出来区别的。

  2. 所以我们从根本上改变了思想，不按照技术数组简单输出，并做出如下改变

  3. 依然通过max和min创建计数数组，但计数时，把技术数组的次数变为累加值，即 包括自己在内前面所有元素出现次数的累加和 ；这是，如果累加次数值 为8，就意味着该元素在排序数组中 应该排在第8位

  4. 输出数组时，新定义一个和未排序数组大小相同的数组，因为我们一会要用到未排序数组，所以先备份一个

  5. 利用未排序数组 和 计数数组，从最右侧向最左侧遍历，遍历到一个元素，先找到其对应在计数数组中的 累加次数值 x（即该元素排序位置），就把其覆盖到备份数组中 x-1的索引处，同时 累加次数值-1（这样若左边还有相同元素，下次就会覆盖到前一个位置，就稳定了）

  6. 遍历完成，覆盖完成，排序完成，备份数组覆盖原未排序数组即可。
    图片来自网课恋上数据结构与算法，腾讯课堂在这里插入图片描述

计数排序时间空间复杂度

  1. 最好最坏平均时间复杂度：O（n+k）其中n为排序数组长度，k为max-min+1（计数数组长度）
  2. 空间复杂度O（n+k），来自计数数组和备份数组
  3. 因为不是比较排序，所以最好最坏平均时间复杂度都一样
  4. 属于空间换时间的典例

计数排序基础版 代码及输出

比较简单，直接看后面改进版把
void countingSort(vector<int> &array)
{
    int max  = array[0];
    for(int index = 1;index<array.size();index++){
        if(max<array[index]){
            max = array[index];
        }
    }

    int* counts = new int[max+1]{0};
    for(int index = 0;index<array.size();index++){
        counts[array[index]]++;
    }
    
    vector<int> sortedArray;
    for(int index = 0;index <=max;index++){
        for(int i = 0;i<counts[index];i++){
            sortedArray.push_back(index);
        }
    }
    
    array = sortedArray;
}

输入数组：
6 9 6 7 5 8 8 29 15 11 10
计数排序基础版
索引 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
次数 0 0 0 0 0 1 2 1 2 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
算法用时：（微秒）
[AlgoTime: 6001 us]
排序结果：
5 6 6 7 8 8 9 10 11 15 29

计数排序第一次改进版 代码及输出

void countingSort2nd(vector<int> &array){
    //遍历排序数组，记录最大值与最小值
    int max = array[0];
    int min = array[0];
    for(int i = 1;i<array.size();i++){
        if(max<array[i]){
            max = array[i];
        }
        if(min>array[i]){
            min = array[i];
        }
    }

    //创建计数数组，长度为max-min+1，记住创建数组【】里的是长度，不是最大索引
    int *counts = new int[max - min + 1]{0};

    //进行计数，以及计数结果显示
    for(int i = 0;i<array.size();i++){
        counts[array[i]-min]++;
    }

    //按照计数数组，对array进行重置
    int arrayIndex = 0;
    for(int i = 0;i<max-min+1;i++){
        while (counts[i]-->0)
        {
            array[arrayIndex] = i+min;
            arrayIndex++;
        }
    }
}

输入数组：
-6 9 6 7 5 8 8 29 15 11 10
计数排序基础版
索引 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 
次数 1 0 0 0 0 0 0 0 0 0 0 1 1 1 2 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1
算法用时：（微秒）
[AlgoTime: 7003 us]
排序结果：
-6 5 6 7 8 8 9 10 11 15 29

计数排序终极版 代码及输出（重要）

void countingSort3rd(vector<int> &array){
    //遍历未排序数组，记录最大最小值
    int min = array[0];
    int max = array[0];
    for(int i = 1; i<array.size();i++){
        if(min>array[i]){
            min = array[i];
        }
        if(max <array[i]){
            max = array[i];
        }
    }

    //定义计数数组，进行计数
    int* counts = new int [max -min +1]{0};
    for(int i = 0;i<array.size();i++){
        counts[array[i]-min]++;
    }

    //在原有计数数组的基础，对计数值进行累加，把计数值改为 该元素在排序数组中的位置
    int locatingNum = 0;
    for(int i = 0;i<max-min+1;i++){
        if(counts[i] == 0){//如果排序数组中没有这个元素（计数值为0），不进行累加
            continue;
        }
        locatingNum = locatingNum + counts[i];
        counts[i] = locatingNum;
    }

    //打印累加计数数组
    countsIndexPrint(min,max);
    cout<<endl;
    arrayPrint(counts,max-min+1);  
    
    //定义临时数组，根据累加计数数组的位置值，从右到左遍历未排序数组，把元素插入到对应位置
    int* temp = new int[array.size()];
    for(int index = array.size()-1;index>=0;index--){
        //array[index]-min = counts数组对应元素索引
        //counts[数组对应元素索引] = 数组对应元素在排序序列中的位置
        //counts[数组对应元素索引] - 1 = 数组对应元素在排序数组中的索引
        temp[counts[array[index]-min]-1] = array[index];
        counts[array[index]-min]--;
    }
    
    //用备份数组覆盖原数组
    for (int i = 0; i < array.size(); i++)
    {
        array[i]=temp[i];
    }
}

输入数组：
-6 9 6 7 5 8 8 29 15 11 10
计数排序终极版
索引 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
累加次数 1 0 0 0 0 0 0 0 0 0 0 2 3 4 6 7 8 9 0 0 0 10 0 0 0 0 0 0 0 0 0 0 0 0 0 11
算法用时：（微秒）
[AlgoTime: 6000 us]
排序结果：
-6 5 6 7 8 8 9 10 11 15 29

完整版代码

#include <iostream>
#include <vector>
#include "MeasureAlgoTime.hpp"
using namespace std;

void vectorPrint(vector<int> &array)
{
    for (int i = 0; i < array.size(); i++)
    {
        cout << array[i] << ' ';
    }
    cout << endl;
}

void arrayPrint(int array[],int length){
    cout<<"次数"<<" ";
    for(int i = 0;i<length;i++){
        cout<<array[i]<<" ";
    }
}

void countsIndexPrint(int min,int max){
    cout<<"索引"<<" ";
    for(int i =min;i<=max;i++){
        cout<<i<<" ";
    }
}

void countingSort(vector<int> &array)
{
    int max  = array[0];
    for(int index = 1;index<array.size();index++){
        if(max<array[index]){
            max = array[index];
        }
    }

    int* counts = new int[max+1]{0};
    for(int index = 0;index<array.size();index++){
        counts[array[index]]++;
    }
    countsIndexPrint(0,max);
    cout<<endl;
    arrayPrint(counts,max-0+1);
    
    vector<int> sortedArray;
    for(int index = 0;index <=max;index++){
        for(int i = 0;i<counts[index];i++){
            sortedArray.push_back(index);
        }
    }
    
    array = sortedArray;
}

void countingSort2nd(vector<int> &array){
    //遍历排序数组，记录最大值与最小值
    int max = array[0];
    int min = array[0];
    for(int i = 1;i<array.size();i++){
        if(max<array[i]){
            max = array[i];
        }
        if(min>array[i]){
            min = array[i];
        }
    }

    //创建计数数组，长度为max-min+1，记住创建数组【】里的是长度，不是最大索引
    int *counts = new int[max - min + 1]{0};

    //进行计数，以及计数结果显示
    for(int i = 0;i<array.size();i++){
        counts[array[i]-min]++;
    }
    countsIndexPrint(min,max);
    cout<<endl;
    arrayPrint(counts,max-min+1);

    //按照计数数组，对array进行重置
    int arrayIndex = 0;
    for(int i = 0;i<max-min+1;i++){
        while (counts[i]-->0)
        {
            array[arrayIndex] = i+min;
            arrayIndex++;
        }
    }
}

void countingSort3rd(vector<int> &array){
    //遍历未排序数组，记录最大最小值
    int min = array[0];
    int max = array[0];
    for(int i = 1; i<array.size();i++){
        if(min>array[i]){
            min = array[i];
        }
        if(max <array[i]){
            max = array[i];
        }
    }

    //定义计数数组，进行计数
    int* counts = new int [max -min +1]{0};
    for(int i = 0;i<array.size();i++){
        counts[array[i]-min]++;
    }

    //在原有计数数组的基础，对计数值进行累加，把计数值改为 该元素在排序数组中的位置
    int locatingNum = 0;
    for(int i = 0;i<max-min+1;i++){
        if(counts[i] == 0){//如果排序数组中没有这个元素（计数值为0），不进行累加
            continue;
        }
        locatingNum = locatingNum + counts[i];
        counts[i] = locatingNum;
    }

    //打印累加计数数组
    countsIndexPrint(min,max);
    cout<<endl;
    arrayPrint(counts,max-min+1);  
    
    //定义临时数组，根据累加计数数组的位置值，从右到左遍历未排序数组，把元素插入到对应位置
    int* temp = new int[array.size()];
    for(int index = array.size()-1;index>=0;index--){
        //array[index]-min = counts数组对应元素索引
        //counts[数组对应元素索引] = 数组对应元素在排序序列中的位置
        //counts[数组对应元素索引] - 1 = 数组对应元素在排序数组中的索引
        temp[counts[array[index]-min]-1] = array[index];
        counts[array[index]-min]--;
    }
    
    //用备份数组覆盖原数组
    for (int i = 0; i < array.size(); i++)
    {
        array[i]=temp[i];
    }
}


int main()
{
    Tools::Time::AlgoTimeUs time1;
    Tools::Time::AlgoTimeUs time2;
    Tools::Time::AlgoTimeUs time3;

    vector<int> array;
    array = {6, 9, 6, 7, 5, 8, 8, 29, 15, 11, 10};
    vector<int> array2 = {-6, 9, 6, 7, 5, 8, 8, 29, 15, 11, 10};
    vector<int> array3 = array2;

    cout<<"输入数组："<<endl;
    vectorPrint(array);
    time1.start();
    cout << "计数排序基础版" << endl;
    countingSort(array);
    cout << "算法用时：（微秒）";
    time1.printElapsed();
    cout << "排序结果：" << endl;
    vectorPrint(array);
    cout << ' ' << endl;

    cout<<"输入数组："<<endl;
    vectorPrint(array2);
    time2.start();
    cout << "计数排序第一次改进版" << endl;
    countingSort2nd(array2);
    cout <<endl<< "算法用时：（微秒）";
    time2.printElapsed();
    cout << "排序结果：" << endl;
    vectorPrint(array2);
    cout << ' ' << endl;

    cout<<"输入数组："<<endl;
    vectorPrint(array3);
    time3.start();
    cout << "计数排序终极版" << endl;
    countingSort3rd(array3);
    cout <<endl<< "算法用时：（微秒）";
    time3.printElapsed();
    cout << "排序结果：" << endl;
    vectorPrint(array3);
    cout << ' ' << endl;
    return 0;
}
SuSA_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 计数排序算法的实现与改进(含笔试面试题)
MISAYAONE的博客
03-30 2435
计数排序局限性比较大，算法思想：假定输入是有一个小范围内的整数构成的（比如年龄等），利用额外的数组去记录元素应该排列的位置，思想比较简单。 计数排序是典型的不是基于比较的排序算法，基于比较的排序算法最少也要O(nlogn)，有没有可能创造线性时间的排序算法呢？那就是不基于比较的排序算法； 如果数组的数据范围为0~100，则很适合此算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数
C++实现计数排序(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-01 1046
计数排序 计数排序基于一个假设，待排序数列的所有数均为整数，且出现在（0，k）的区间之内。 如果 k（待排数组的最大值） 过大则会引起较大的空间复杂度，一般是用来排序 0 到 100 之间的数字的最好的算法，但是它不适合按字母顺序排序人名。 计数排序不是比较排序，排序的速度快于任何比较排序算法。 时间复杂度为 O（n+k），空间复杂度为 O（n+k） 算法的步骤如下： /* 找出待排序的数组中最大和最小的元素 统计数组中每个值为 i 的元素出现的次数，存入数组 C 的第 i 项 6 / 18 对所有的计数
十大排序算法——计数排序
https://juejin.cn/user/4248168663101239/posts
07-18 3067
计数排序一. 计数排序介绍二. 计数排序基础版三. 计数排序改进版四. 优化最终版本_空间节省 一. 计数排序介绍 计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。 算法分析 当输入的元素是n 个0到k之间的整数时，它的运行时间是 O(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。 由于用来计数的数组C的长度取
计数排序的优化
weixin_43300894的博客
05-17 434
一、计数排序 计数排序是将序列中的数值转化为数组的下标，当数字a出现一次时，就把数组中对应a下标的值加1。这些数据需要存放在额外开辟的数组空间中(我们把该数组成为统计数组)，计数排序的时间复杂度为线性的，它适用于在一定范围内的整数排序，在取值范围不是很大的情况下，它的性能可以超过那些时间复杂度为O(nlogn)的排序。 当待排序的数据为95、94、91、98、99、90、99、93、91、92时，我们还以数列的最大值来决定统计数组的长度时，要创建一个长度为100的数组，那么从0-89的位置空间就都浪费了。
计数排序及优化
er3456qi的专栏
01-20 703
！！！！！！！这是原创--------转载请注出处！！！！！！！！ 最近在看算法导论的公开课视频，刚好看到计数排序，下面是引用的维基百科关于计数排序的解释： 当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。 由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大
计数排序及其C++实现
Dev-L的博客
05-30 3166
计数排序 COUNTING_SORT计数排序假设n个输入元素中每一个都是在0到k区间内的一个整数。其中k为某个整数。当k=O(n)时，排序的运行时间为Θ（n）.计数排序的基本思想是：对每一个输入元素x，确定小于x的元素个数。利用这一信息，就可以直接吧x放到它在输出数组中的位置上了。例如，如果有17个元素小于x,则x就应该在第18个输出位置上。当有几个元素位置相同时，这一方案要略作修改。因为不能把他们
数据结构与算法分析C++语言描述第四版参考答案
10-13
《数据结构与算法分析C++语言描述第四版》是一本深度探讨数据结构和算法的经典教材。这本书由Mark Allen Weiss撰写，旨在帮助读者理解和掌握如何在C++编程环境中有效地设计和实现数据结构及算法。第四版更新了内容，...
《恋上数据结构》第1季度 + 第2季 完整学习笔记，从0实现的 Java 数据结构大全。.zip
最新发布
06-16
《恋上数据结构》的学习笔记包含了第一和第二季度的完整内容，这是一份全面的Java数据结构教程，适合从零开始学习数据结构的大学生。这份资料涵盖了C/C++/JAVA/Python等多种编程语言的数据结构学习，是编程初学者的...
C++数据结构实现之Sorts.zip
06-04
在IT领域，数据结构是计算机科学的基础，它研究如何组织和管理数据以便高效...在"Sorts.zip"中，你可能会找到上述排序算法的C++实现代码，通过阅读和实践这些代码，你可以加深对数据结构和算法的理解，并提高编程技巧。
关于计数排序的一点思考
xjy95的博客
04-04 448
今天看《算法导论》时，看到计数排序，实现简单的同时，时间复杂度也较小，当待排序元素在[0, k]的区间以及k=O(n)时，整个算法的时间复杂度仅为O(n)，低于所有比较排序算法。于是我不禁感到奇怪：既然计数排序有着这样的优点，为什么并不见很多地方用到呢？void countingSort(int *a, int *b, int n) {//a-待排序数组，b-输出数组 int max = INT...
BJFU_数据结构习题_299计数排序
雪地行进
12-04 1590
欢迎登录北京林业大学OJ系统 http://www.bjfuacm.com 299计数排序 描述 有一种简单的排序算法，叫做计数排序。这种排序算法对一个待排序的表进行排序，并将排序结果存放到另一个新的表中。必须注意的是，表中所有待排序的关键字互不相同，计数排序算法针对表中的每个记录，扫描待排序的表一趟，统计表中有多少个记录的关键字比该记录的关键字小。假设针对某一个记录，统计出的计数值为c，那么，这...
计数排序及其扩展思路
Neil的博客
01-15 5759
(1)原理和代码以及时间复杂度分析           1.计数排序的原理：设被排序的数组为A,排序后存储到B，C为临时数组。所谓计数，首先是通过一个数组C[i]计算大小等于i的元素个数，此过程只需要一次循环遍历就可以；在此基础上，计算小于或者等于i的元素个数，也是一重循环就完成。下一步是关键：逆序循环，从length[A]到1，将A[i]放到B中第C[A[i]]个位置上。原理是：C[A[i]]
计数排序以及计数排序的一种优化
u012749168的博客
10-18 377
public class countSort { public static void CountingSort(int A[], intB[], int len, int k){ int CountArr[] = new int[k]; int i; for (i = 0; i
算法——排序算法——计数排序优化
LOLUN9的博客
10-20 1170
在前几篇博客中讲了计数排序的一般方法，理解起来比较简单。但是上一次提到的计数排序只是简单的按照数组下标统计输出了元素的值，并没有真正将原来的数据进行排序。在日常的使用当中，往往会出现相同的数据进行排序，如果还使用前几篇的方法就会发现有些力不从心了，下面来说说如何对计数排序进行优化。 比如说有几个人的成绩分别是：小红：90，小橙：99，小黄：95，小绿：94，小青：95。将这些学生的成绩按照从低到...
C++计数排序
四叶草姚的博客
09-24 2693
计数排序（Counting sort）是一种稳定的线性时间排序算法。 当输入的元素是 n个min到max之间的整数时候，k = max - min +1,它的时间复杂度是O(n+k)。 计数排序不是比较排序，排序的速度快于任何比较排序算法。当然这是一种牺牲空间换取时间的做法，而且当O(k)&amp;gt;O(nlog(n))的时候其效率反而不如基于比较的排序（基于比较的排序的时间复杂度在理论上的下限是O...
计数排序在C++上的实现
qq_18734867的博客
10-17 843
最近算法导论，学到了计数排序，顺便用C++实现了一下，代码如下所示：#include<iostream> using namespace std; void Countingsort(int A[],int B[],int k,int n){ //k为数组A中的最大值，n为数组A的长度 int C[k+1]; int i,j; for(i=0;
c++实现快速排序（优化版本）
orange_monkey的博客
12-23 238
#include<iostream> using namespace std; //交换两个元素 void Swap_Elem(int *arr, int first, int second) { int temp = arr[first]; arr[first] = arr[second]; arr[first] = temp; } //将元素移动到正确位置 int Patition(int *arr, int low, int high) { //三数取中，确保枢轴不是最小或者最
计数排序算法——C++
净无邪博客
11-24 3311
​计数排序是时间复杂度为O(n + m)的算法，空间复杂度为O(n + m)；算法思想跟散列表哈希hash有些类似，主要是利用一段有序数组计算对应元素的下表个数，然后依次输出有数组元素进行排列。基本计数排序是不稳定算法，但是优化后计数排序是稳定算法。本文主要讲解基本计数排序和优化后计数排序。 使用条件：数组必须是整数或者能全部映射为整数，数组所有元素必须在有限较集中范围； 一、具体实现步骤 1.计算原始数组的最大值max和最小值min范围，然后创建一个长度为max--min+1的排序数组sortAr
C/C++计数排序(优化版)-(累加数组)-(稳定版)
疯狂的菜鸡
06-21 586
时间: 2020-06-21
数据结构与算法学习笔记分享（C++）
09-15
本文档是一份关于数据结构与算法学习的笔记，特别关注了C++语言的应用。首先，它强调了数据结构的基础概念，包括数据结构的定义（结构定义和结构操作），逻辑结构（如存储结构和抽象数据类型），以及数据的基本元素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值