精华内容
下载资源
问答
  • 计数排序原理及其Java实现
    2020-10-26 21:22:50

    计数排序的原理及其Java实现

    计数排序是一种线性时间复杂度的排序算法,当输入的元素是n个0到k的整数时,时间复杂度为O(n + k)。

    计数排序的核心在于它会将输入的数据值转化为键存储在额外开辟的数组空间中,它要求排序的内容必须是有确定范围的整数。

    计数排序在排序过程中没有进行比较,排序的速度超过所有的比较排序方法。

    计数排序是用来排序0到100之间(小范围)的数字的最好的算法。

    通俗地理解,例如有 10 个年龄不同的人,统计出有 8 个人的年龄比 A 小,那 A 的年龄就排在第 9 位,用这个方法可以得到其他每个人的位置,也就排好了序。

    算法的步骤如下:

    ​ 1、 找出待排序数组中最大的数字maxValue(如果存在负数还需要找出最小的数字)

    ​ 2、 新建一个数组C[maxValue + 1],统计待排序数组中数字i出现的次数,放入C[]

    ​ 3、 C[i]中存放着数字i出现的次数,新建一个数组res[],将i逐个放进res[]中即可

    public int[] countSort(int[] nums) {
        // 1、寻找数组中最大值
        int maxValue = 0;
        for (int num : nums) {
            maxValue = Math.max(maxValue, num);
        }
    
        // 2、创建辅助数组C,C[i]记录数字i出现的次数
        int[] C = new int[maxValue + 1];
        for (int num : nums) {
            C[num]++;
        }
    
        // 3、根据数组C记录的次数,填充排好序的数组res
        int[] res = new int[nums.length];
        // res的索引 通过它我们来填充res数组
        int index = 0;
        for (int i = 0; i < C.length; i++) {
            while (C[i] > 0) {
                res[index++] = i;
                C[i]--;
            }
        }
        return res;
    }
    
    更多相关内容
  • 文章目录计数排序概念实现方式关于计数排序的性能参数代码实现 计数排序概念 计数排序是一个非基于比较的排序算法。它的优势在于在对一定范围内的整数排序时,它的复杂度为Ο(n+k)(其中k是整数的范围),快于任何...

    计数排序概念

    计数排序是一个非基于比较的排序算法。它的优势在于在对一定范围内的整数排序时,它的复杂度为Ο(n+k)(其中k是整数的范围),快于任何比较排序算法。当然这是一种牺牲空间换取时间的做法。

    动图演示
    在这里插入图片描述

    实现方式

    例如,已知要排序的数组里的数的取值范围,要用最快的速度将其排序。
    假如范围是1-9,如上面动图所示
    一、找到数组中最大值和最小值
    二、建立一个max-min+1的数组空间,每个元素初始值为0
    三、遍历要排序的无序数组
    比如说,第一个数是2,那么数组下标为2的元素加1
    第二个数是3,那么数组下标为3的元素加1
    以此类推
    四、到最后,我们就得到了一个数组,数组中每一个值,代表了下标值在排序数组内出现的次数。
    五、直接遍历我们得到的数组,输出下标值,元素的值为多少,就输出几次。

    排序完成

    在取值范围不是很大的情况下,计数排序性能甚至快过O(n logn)O(n logn)的排序

    关于计数排序的性能参数

    1、时间复杂度
    O(n)O(n)

    2、空间复杂度
    O(n)O(n)

    3、是否稳定
    稳定

    代码实现

    /*
     * @Descripttion: 
     * @version: 
     * @Author: edisonhuang
     * @Date: 2020-03-12 16:17:54
     * @LastEditors: edisonhuang
     * @LastEditTime: 2020-03-12 16:32:34
     */
    #include <iostream>
    void Print(int arr[], int length);
    void CountSort(int arr[],int length);
    using namespace std;
    
    int main()
    {   
        int arr[] = {13, 14, 8, 100, 25, 75, 9, 64, 12};
        int len = (int) sizeof(arr) / sizeof(*arr);
        Print(arr, len);
        CountSort(arr, len);
        Print(arr, len);
        
        return 0;
    }
    
    void CountSort(int arr[],int length){
        // 找最大值和最小值
        int max,min;
        max = arr[0];
        min = arr[0];
        for (int i = 0; i < length; i++)
        {
            if(arr[i] > max)
            {
                max = arr[i];
            }
            if(arr[i] < min)
            {
                min = arr[i];
            }
            
        }
        //根据最大最小值开辟数组
        int *count;
        count = (int *)malloc(sizeof(int ) * (max-min+1));
        memset(count,0,sizeof(int ) * (max-min+1));
    
        // 统计原数组各值个数
        for (int i = 0; i < length; i++)
        {
            count[arr[i]-min]++;
        }
        // 放回原数组
        int j = 0;
        for (int  i = 0; i < max-min+1; i++)
        {
            while (count[i] !=0 )
            {
                arr[j] = i+min;
                j++;
                count[i]--;
            }
            
        }
        
        
    }
    
    void Print(int arr[], int length)
    {
        for (int i = 0; i < length; i++)
        {
            cout << arr[i] << " ";
        }
        cout << endl;
    }
    
    
    展开全文
  • 计数排序条件算法描述代码 计数排序不是基于比较的排序算法,其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中 条件 作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。 ...


    计数排序 不是基于比较的排序算法,其核心在于 将输入的数据值转化为键存储在额外开辟的数组空间中

    条件

    作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数
    计数排序变形桶排序. 基数排序.

    算法描述

    在这里插入图片描述

    1. 找出待排序的数组中最大和最小的元素,然后建立一个数组C用于统计待排数组中最小元素到最大元素区间中每个元素出现次数
    2. 统计数组中每个值为i的元素出现的次数,存入数组C的第i项;
    3. 对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加);
    4. 反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1。

    代码

    public static void countSort(int[] a, int max, int min) {
         int[] b = new int[a.length];//存储数组
         int[] count = new int[max - min + 1];//计数数组
    
         for (int num = min; num <= max; num++) {
            //初始化各元素值为0,数组下标从0开始因此减min
            count[num - min] = 0;
         }
    
         for (int i = 0; i < a.length; i++) {
            int num = a[i];
            count[num - min]++;//每出现一个值,计数数组对应元素的值+1
         }
    
         for (int num = min + 1; num <= max; num++) {
            //加总数组元素的值为计数数组对应元素及左边所有元素的值的总和
            count[num - min] += sum[num - min - 1]
         }
    
         for (int i = 0; i < a.length; i++) {
              int num = a[i];//源数组第i位的值
              int index = count[num - min] - 1;//加总数组中对应元素的下标
              b[index] = num;//将该值存入存储数组对应下标中
              count[num - min]--;//加总数组中,该值的总和减少1。
         }
    
         //将存储数组的值一一替换给源数组
         for(int i=0;i<a.length;i++){
             a[i] = b[i];
         }
    }
    
    展开全文
  • 计数排序(CountSort) 概念介绍 计数排序是一个不是基于比较的排序算法,该算法于1954年由 Harold H. Seward 提出。 计数排序是一种基于特定范围内的键的排序技术。它的工作原理是计算具有不同键值的对象的数量(类似...

    计数排序(CountSort)

    概念介绍

    计数排序是一个不是基于比较的排序算法,该算法于1954年由 Harold H. Seward 提出。

    计数排序是一种基于特定范围内的键的排序技术。它的工作原理是计算具有不同键值的对象的数量(类似于散列)。然后做一些算术来计算每个对象在输出序列中的位置。

    它的优势在于在对一定范围内的整数排序时,它的复杂度为Ο(n+k)(其中k是整数的范围),快于任何比较排序算法。

    当然这是一种牺牲空间换取时间的做法,而且当O(k)>O(nlog(n))的时候其效率反而不如基于比较的排序(基于比较的排序的时间复杂度在理论上的下限是O(nlog(n)), 如归并排序,堆排序)

    从下面的源码示例可以看出:计数排序没有用到元素间的比较,它利用元素的实际值来确定它们在输出数组中的位置

    排序过程

    • 使用一个计数数组count来存储每个唯一对象的计数,注意: 计算数组count使用对象的实际值作为数组下标
    • 修改count数组,存储当前下标之前对象计数的累加值
    • 利用元素的实际值如val来确定它们在输出数组中的位置count[val]-1,同时将count[val]的值-1【针对相同的元素进行处理】g5ZOl,size_19,color_FFFFFF,t_70,g_se,x_16)

    注意点

    1. 如果待排序集合的数据范围不是明显大于要排序的对象的数量,计数排序的效率很高,能取得线性计算时间。
    2. 不是基于比较的排序。它的运行时间复杂度为O(n),空间与数据范围成正比。
    3. 经常被用作另一种排序算法(如基数排序)的子程序
    4. 计数排序使用部分哈希来计算数据对象的出现次数
    5. 计数排序支持负数排序
    6. 经计数排序,输出序列中值相同的元素之间的相对次序与他们在输入序列中的相对次序相同,换句话说,计数排序算法是一个稳定的排序算法

    源码示例

    public class CountSortExample {
        public static void main(String[] args){
            int[] arr = {-1,20,-8, 100,2,5,8, 10 };
            countSort(arr);
            printArray(arr);
        }
        
        static void countSort(int[] arr){
            int max = Arrays.stream(arr).max().getAsInt();
            int min = Arrays.stream(arr).min().getAsInt();
            int range = max - min + 1;
            int count[] = new int[range];
            int output[] = new int[arr.length];
            for (int i = 0; i < arr.length; i++) {
                count[arr[i] - min]++;
            }
    
            for (int i = 1; i < count.length; i++) {
                count[i] += count[i - 1];
            }
    
            for (int i = arr.length - 1; i >= 0; i--) {
                output[count[arr[i] - min] - 1] = arr[i];
                count[arr[i] - min]--;
            }
    
            for (int i = 0; i < arr.length; i++) {
                arr[i] = output[i];
            }
        }
    
        static void printArray(int[] arr){
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println("");
        }
    }
    
    
    展开全文
  • 主要介绍了Python实现的计数排序算法,简单描述了计数排序的算法原理并结合具体实例形式分析了Python计数排序的相关实现与使用技巧,需要的朋友可以参考下
  • 理解计数排序算法的原理和实现

    千次阅读 2018-10-11 10:03:34
    计数排序(Counting sort)是一种稳定的线性时间排序算法,其平均时间复杂度和空间复杂度为O(n+k),其中n为数组元素的个数,k为待排序数组里面的最大值。同样具有线性时间排序的算法还有桶排序和基数排序,这一点...
  • 计数排序不是基于比较的排序,如果待排序数据的范围在0~k之间,那么它的时间复杂度是O(k+n)的。原理如下:首先假设待排序数据的范围在0~k之间,而且都是整数。定义一个辅助数组int[] C = new int[k+1]。对于待排序...
  • Python实现计数排序

    千次阅读 2020-07-19 00:39:20
    Python实现计数排序
  • 排序算法:基数排序与计数排序

    千次阅读 多人点赞 2022-01-11 12:24:53
    基数排序是基于计数排序的算法,每次都需要使用计数排序从而实现基数排序。 那么什么叫基于计数排序?我们首先要明白基数排序的原理: 每次对数字的一个数位(个位、十位、百位......)进行比较,每次比较后进行一...
  • 主要介绍了JS实现的计数排序与基数排序算法,结合实例形式简单分析了计数排序与基数排序的原理与JS实现技巧,需要的朋友可以参考下
  • 桶排序和计数排序

    千次阅读 2019-04-17 13:51:30
    1.算法原理 1.桶排序核心思想就是将要排序的数据分到几个有序的桶里,每个通在分别进行排序,每个桶排序完成后再把每个桶里的数据按照顺序依次取出,组成新的序列,该序列就是排好序的序列。类似归并排序中中的分治...
  • js排序算法详解-计数排序

    千次阅读 2017-09-21 20:18:05
    js系列教程5-数据结构和算法全解js排序算法详解-计数排序计数排序就是遍历数组记录数组下的元素出现过多次,然后把这个元素找个位置先安置下来,简单点说就是以原数组每个元素的值作为新数组的下标,而对应小标的新...
  • 一、什么是计数排序 1.概念 计数排序(Counting sort)是一种非基于比较的排序算法,其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中以达到排序的效果 2.算法原理 给定一组取值范围为0到9的无序序列:1...
  • 这篇博客将主要介绍三种时间复杂度是O(n)的排序算法:桶排序、计数排序计数排序。因为这些排序算法的时间复杂度都是线性的,所以也把这类排序算法称为线性排序。之所以能够做到线性的时间复杂度,主要原因是这几个...
  • 前言 比较类排序就是需要通过比较数组中的数据来交换位置,实现有序 而非比较类,例如基数排序,就不需要比较...实际上计数排序、基数排序就是特殊的桶排序,桶排序是一种排序的思想,其实现包括计数排序和基数排序两种
  • 冒泡排序算法的基本原理就是比较相邻两个数字的大小。将两个数中比较大的那个数交换到靠后的位置,不断交换下去就可以将最大的那两个数放到队列的尾部。然后重头再次交换)(交换list.lenght-1次),直到将数列排成有序...
  • C++ 计数排序

    2019-03-15 01:13:06
    计数排序原理: (1)首先,找出最大的元素,给“count[ ]”申请“最大元素的下标+1”个单元(因为数组下标是从0开始的,所以要+1); (2)然后,统计每个元素出现的次数,把次数存到“count[ ]”里; (3)最后...
  • 计数排序

    2014-06-04 15:56:38
    计数排序原理计数排序
  • 排序算法之计数排序 ( C语言版 )

    千次阅读 2018-10-07 11:37:38
    计数排序计数排序又称为鸽巢原理,是对哈希直接定制法变形应用,是一种稳定的算法,它的优势在于在对一定范围内的整数排序时,它的复杂度为Ο(n+k)(其中k是整数的范围),快于任何比较排序算法,当然这是一种牺牲...
  • 基本原理: 创建一个长度为 k+1 的数组 count[],它的 count[i] 的值对应输入数组中 i 出现的次数。通过遍历一次输入数组并统计每个元素出现次数,最后遍历 count[] 输出。   二、时间复杂度 计算排序的时间...
  • 基数排序、桶排序和计数排序的区别

    万次阅读 多人点赞 2019-04-18 00:11:08
    1.桶排序(Bucket Sort) 基本思路是: 将待排序元素划分到不同的痛。先扫描一遍序列求出最大值 maxV 和最小值 minV , 设桶的个数为 k ,则把区间 [minV, maxV] 均匀划分成 k 个区间,每个区间就是一个桶。将序列中的...
  • C++实现计数排序

    千次阅读 2019-11-18 19:57:42
    计数排序只能用在数据范围不大的场景中,如果数据范围 k 比要排序的数据 n 大很多,就不适合用计数排序了。而且,计数排序只能给非负整数排序,如果要排序的数据是其他类型的,要将其在不改变相对大小的情况下,转化...
  • 我们以[1 7 8 7 9 8 10 4]这个序列为例说明计数排序算法的实现原理 当未开始排序时,效果如下图 先找到待排序序列中最大值10和最小值1,此时效果如下图 新建一个长度为N=最大值10-最小值1+1=10的数组,新数组中值...
  • 一、计数排序 1、介绍。 计数排序是一个非基于比较的排序算法,该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时,它的复杂度为Ο(n+k)(其中k是整数的范围),快于任何比较排序...
  • C语言计数排序

    2022-04-20 12:05:26
    深入浅出计数排序原理与实现方法。
  • 计数排序 1 基本原理 1 核心思想:计数排序是一种稳定的线性时间排序算法。计数排序使用一个额外的数组 C ,其中第i个元素是待排序数组 A中值等于 i的元素的个数。然后根据数组 C 来将 A中的元素排到正确的位置...
  • 计数排序和基数排序

    2018-11-14 15:18:54
    计数排序是一种非比较性排序,时间复杂度为O(n + k),主要适用于排序的数组极大值和极小值直接的差不大的情况,如果待排序数组极值差过大,则会造成过多的空间浪费,具体原理如图所示:   原理  实现 ...
  • 1.计数排序:Counting Sort 计数排序是一个非基于比较的排序算法,该算法于1954年由 Harold H. Seward 提出,它的优势在于在对于较小范围内的整数排序。它的复杂度为Ο(n+k)(其中k是待排序数的最大值),快于任何...
  • 计数排序是一个非基于比较的排序算法,又称为鸽巢原理,是对哈希直接定址法的变形应用,该算法于1954年由 Harold H. Seward 提出。它的排序思想是:首先统计相同元素的个数,然后将个数存储在用于计数的数组的相应...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,153
精华内容 21,661
关键字:

计数排序原理

友情链接: 76636720.rar