算法 计数排序

参考博客:常用排序算法总结(二)

计数排序 counting sort

  1.计数排序是一种非常快捷的稳定性强的排序方法,时间复杂度O(n+k),其中n为要排序的数的个数,k为要排序的数的组大值。计数排序对一定量的整数排序时候的速度非常快,一般快于其他排序算法。但计数排序局限性比较大,只限于对整数进行排序。计数排序是消耗空间发杂度来获取快捷的排序方法,其空间发展度为O(K)同理K为要排序的最大值。

  2.计数排序的基本思想为一组数在排序之前先统计这组数中其他数小于这个数的个数,则可以确定这个数的位置。例如要排序的数为 7 4 2 1 5 3 1 5;则比7小的有7个数,所有7应该在排序好的数列的第八位,同理3在第四位,对于重复的数字,1在1位和2位(暂且认为第一个1比第二个1小),5和1一样位于6位和7位。

计数排序非常基础,他的主要目的是对整数排序并且会比普通的排序算法性能更好。例如,输入{1, 3, 5, 2, 1, 4}给计数排序,会输出{1, 1, 2, 3, 4, 5}。这个算法由以下步骤组成:

  初始化一个计数数组,大小是输入数组中的最大的数。
  遍历输入数组,遇到一个数就在计数数组对应的位置上加一。例如:遇到5,就将计数数组第五个位置的数加一。
  把计数数组直接覆盖到输出数组(节约空间)。

时间复杂度:O(n)

统计一个列表内每个元素出现的个数。用于小规模范围内计算!

弊端:

  有限定!为排序需要新建一个列表,开辟一块内存空间,而且这个空间的大小取决于排序列表的最大值。

  如果一个要排序的列表中仅有,【1,10000】这两个数,那么我们统计的话,创建的用于计数的列表就要开一一个可以存放10000个数的内存空间。这样导致的结果就是,其他的数无用并且损耗性能,时间复杂度没变但是空间复杂度增加了!这也间接的暴露了范围取值的弊端。

算法实现:

def count_sort(li, maxnum=100):
    """
    新建一个列表,往列表内写值
    :param li:
    :param maxnum:
    :return:
    """
    count = [0 for i in range(maxnum+1)]  #创建用以计数的所有元素都是0的列表,
    result = []
    for i in li: #遍历要计数的列表,每个元素对应的索引位置的数加1
        count[i] += 1
    for num, count in enumerate(count): #对已经完成计数的列表进行枚举打印,格式(数字,次数)
        for i in range(count): #再通过次数创建一个循环,出现多少次就把对应的数写入列表多少次
            result.append(num)

def count_sorts(li, max_num):
    """
    仅在当前列表下操作,按照次数重写列表
    :param li:
    :param max_num:
    :return:
    """
    count = [0 for i in range(max_num + 1)]
    for num in li:
        count[num] += 1
    i = 0
    for num,m in enumerate(count):
        for j in range(m):
            li[i] = num
            i += 1
    return li

li = [3,4,1,2,5,6,6,5,4,3,3]
print(count_sorts(li,max(li)))

应用:

  有一个数组[3,4,1,2,5,6,6,5,4,3,3]请写一个函数,找出该数组中没有重复的数的总和(上面的没有重复数的总和为 1+2=3)。

def count_sorts(li, max_num):
    """
    计数排序引申,求和
    :param li: 传入的列表
    :param max_num:列表中最大值
    :return:和 sums
    """
    counts = [0 for i in range(max_num + 1)]
    for num in li:
        counts[num] += 1
    sums = 0
    for num,count in enumerate(counts):
        # print(num,count) #打印列表内对应数字出现的次数
        if count == 1:
            sums += num
    return sums

li = [3,4,1,2,5,6,6,5,4,3,3]
print(count_sorts(li,max(li)))
时间: 2024-10-01 07:27:05

算法 计数排序的相关文章

经典排序算法 - 计数排序Counting sort

经典排序算法 - 计数排序Counting sort 注意与基数排序区分,这是两个不同的排序 计数排序的过程类似小学选班干部的过程,如某某人10票,作者9票,那某某人是班长,作者是副班长 大体分两部分,第一部分是拉选票和投票,第二部分是根据你的票数入桶 看下具体的过程,一共需要三个数组,分别是待排数组,票箱数组,和桶数组 var unsorted = new int[] { 6, 2, 4, 1, 5, 9 };  //待排数组 var ballot = new int[unsorted.Len

6.算法-计数排序

//算法-计数排序var cc=cc||consolefunction counting_sort(A,B,k){    var C=[]    for(var i=0;i<k;i++){        C[i]=0    }    for(var j=0;i< A.length;j++){        C[A[j]]=C[A[j]]+1    }    for(var i=0;i<k;i++){        C[i]=C[i]+C[i-1]    }    for(var j= A

[经典算法]计数排序

概述: 计数排序是一个非基于比较的排序算法,该算法于1954年由 Harold H. Seward 提出.它的优势在于在对一定范围内的集合排序时,它的复杂度为Ο(n+k)(其中k是元素的范围),快于任何比较排序算法. 计数排序本质上是通过计算无序集合中元素出现的次数来决定集合应该如何排序的. 例如一个数组{1, 4, 1, 2, 7, 5, 2},进行计数排序过程 1.使用Count数组记录元素次数 Index: 0 1 2 3 4 5 6 7 8 9 Count: 0 2 2 0 1 1 0

算法-计数排序及其变体

本文由@呆代待殆原创,转载请注明出处. 简介:用于整数排序,不同于比较排序,计数排序假设输入元素的大小在0到k之间,通过计算比 i 小的数的个数而确定 i 的位置. 思路:计算所排序的数组中,比元素 i 小的数的个数 n,如果n=5,那么 i 就应该排列在第6个位置上,通过计算每一个元素的 n 值,我们就能知道每一个元素的位置,因为元素有可能重复,所以我们还有记录重复的数的个数以免把重复的数都重复放置到同一个位置上(当然如果你想去掉重复的数时,可以省略这一步). 算法分析 时间复杂度:Θ(n+k

【vlfeat】O(n)排序算法——计数排序

今天想在网上找一个实现好的er算法来着,没啥具体的资料,无奈只能看vlfeat的mser源码,看能不能修修补补实现个er. 于是,看到某一段感觉很神奇,于是放下写代码,跑来写博客,也就是这段 1 /* ----------------------------------------------------------------- 2 * Sort pixels by intensity 3 * --------------------------------------------------

算法——计数排序与快速排序

计数排序是一种算法复杂度 O(n) 的排序方法,适合于小范围集合的排序.比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序.我们如何设计一个 最高效的排序算法.本文不光给出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和空间复杂度最优. 先看看计数排序的定义 Counting sort (sometimes referred to as ultra sort or math sort[1]) is a sorting algorith

线性排序算法---- 计数排序, 基数排序, 桶排序

排序算法里,除了比较排序算法(堆排序,归并排序,快速排序),还有一类经典的排序算法-------线性时间排序算法.听名字就让人兴奋! 线性时间排序,顾名思义,算法复杂度为线性时间O(n) , 非常快,比快速排序还要快的存在,简直逆天.下面我们来仔细看看三种逆天的线性排序算法, 计数排序,基数排序和桶排序. 1计数排序  counting Sort 计数排序 假设 n个 输入元素中的每一个都是在 0 到 k 区间内的一个整数,当 k= O(N) 时,排序运行的时间为 O(N). 计数排序的基本思想

排序算法 - 计数排序

基本思想 计数排序是一种线性排序算法,它利用了一个数组,因为数组下标的增长是线性的,所以它就把自己的元素转换成新开辟数组的下标.可是下标都是非负数啊?数组当中的值有正有负啊.做一个简单的转化就行了:找到数组中最小元素,用元素值减去,这样一来,所有元素对应的下标就求出来了.(实际上感觉像是个映射函数?)下图中保存的是待排序数组:[-1,-5,-6,-2,1,2,8,2,1,8] 然后跟哈希排序的思路一样:这里.直接开辟一个对应的哈希数组,然后统计每个元素出现的次数.橙色标注出来的表示待排序数组中没

【数据结构】非比较排序算法(实现计数排序和基数排序)

● 计数排序 1.算法思想: 计数排序是直接定址法的变形.通过开辟一定大小的空间,统计相同数据出现的次数,然后回写到原序列中. 2.步骤: 1)找到序列中的最大和最小数据,确定开辟的空间大小. 2)开辟空间,利用开辟的空间存放各数据的个数. 3)将排好序的序列回写到原序列中. 具体实现如下: void CountSort(int *arr, int size) {  assert(arr);  int min = arr[0];  int max = arr[0];  int num = 0;