计数排序详解

一、什么是计数排序?

        计数排序(CountSort)是一个非基于比较的排序算法,该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时,它的复杂度Ο(n+k)(其中k是整数的范围),快于任何比较排序算法。当然这是一种牺牲空间换取时间的做法,而且当O(k)>O(n*log(n))的时候其效率反而不如基于比较的排序(基于比较的排序的时间复杂度在理论上的下限是O(n*log(n)), 如归并排序堆排序)                                                                     ————百度百科

计数排序对输入的数据有附加的限制条件:

        1、输入的线性表的元素属于有限偏序集S;

        2、设输入的线性表的长度为n,|S|=k(表示集合S中元素的总数目为k),则k=O(n)。

在这两个条件下,计数排序的复杂性为O(n)。

        计数排序的基本思想是对于给定的输入序列中的每一个元素x,确定该序列中值小于x的元素的个数(此处并非比较各元素的大小,而是通过对元素值的计数和计数值的累加来确定)。一旦有了这个信息,就可以将x直接存放到最终的输出序列的正确位置上。例如,如果输入序列中只有17个元素的值小于x的值,则x可以直接存放在输出序列的第18个位置上。当然,如果有多个元素具有相同的值时,我们不能将这些元素放在输出序列的同一个位置上,因此,上述方案还要作适当的修改。

        实际上,计数排序是将待排序数组的值对应新数组的下标,新数组首先全部初始化为0,只要遇到待排序元素与新数组下标相等便+1,最终在将新数组中的数据按顺序存回原来的数组,这样数组中的元素就有序了。

        假如有一组数据的范围为101~199范围内的数据,这个时候用计数排序难道还要从0开始创建新的数组吗?这样肯定是浪费空间的,所以我们在创建新数组之前可以先便利出数据的最大值和最小值,那么数组的长度就为:ArrSize = Max - Min + 1在找对应下标的时候每个数据都要减去Min值找到对应下标,在排序过程中在将Min值给加上,这样就可以更好的节省一些空间。

cebda3b12d9b4f0d8967e20fafa45bfc.png

        这样计数排序就完成了。 


 二、计数排序的实现方式:

        计数排序实现其实就比较简单了,按照上述步骤来一步一步的实现出来,代码如下:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>

void CountSort(int *a, int len)//计数排序
{
	assert(a);
	int max = 0, min = 0;//初始化最大最小值
	int i = 0;
	for(i = 1 ; i < len ; i++)//将数据中的最大值最小值找出来
	{
		if(a[max] < a[i])
		{
			max = i;
		}
		
		if(a[min] > a[i])
		{
			min = i;
		}
	}
	
	int range = a[max] - a[min] + 1;//记录新数组长度Max - Min + 1
	
	int *countArr = (int *)malloc(sizeof(int) * range);//开辟新数组
	if(countArr == NULL)//数组检查是否开辟成功
	{
		perror("malloc");
		exit(-1);
	}
	
	memset(countArr, 0, range * sizeof(int));//将新数组全部置零
	
	for(i = 0 ; i < len ; i++)//开始进行计数存储到新数组中
	{
		countArr[a[i] - a[min]]++;//对应下标进行自增
	}
	
	//sort
	int j = 0;
	for(i = 0 ; i < range ; i++)//开始排序
	{
		while(countArr[i]--)
		{
			a[j++] = i + min;//放回原数组
		}
	}
    free(countArr);//销毁创建的数组,排序完成
}

void output(int *a, int len)//输出排序内容
{
	assert(a);
	int i = 0;
	for(i = 0 ; i < len ; i++)
	{
		printf("%3d",a[i]);
	}
	printf("\n");
	return;
}

void Test()
{
	int a[] = { 5, 1, 7, 8, 2, 3, 6, 4 };
	int len = sizeof(a) / sizeof(int);
	CountSort(a, len);
	output(a, len);
	return;
}

int main()
{
	Test();
	return 0;
}

三、计数排序适用场景:

        显然,计数排序适合数据类型大量、集中、重复数据的一把好手,这同时也体现了它的局限性,数据的范围特别大的时候同时也要开辟很大的空间,但是这也不妨碍它在许多排序中的地位,合理利用基数排序或许会有奇效。


4fb66e70e7a34c569cfe3566543173ef.jpeg如果各位大佬觉得有用,不妨给up一个小小的三连支持一下吧~~[玫瑰][玫瑰]

 

  • 9
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
当谈到排序算法时,有许多经典的排序算法可以使用。以下是十大常见的排序算法及其详细解释,使用Python编写的示例代码: 1. 冒泡排序(Bubble Sort): 冒泡排序是一种简单的交换排序算法。它重复地遍历要排序的列表,比较相邻的元素并交换它们,直到整个列表排序完成。 ```python def bubble_sort(arr): n = len(arr) for i in range(n-1): for j in range(n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] return arr ``` 2. 选择排序(Selection Sort): 选择排序是一种简单直观的排序算法。它将列表分为已排序和未排序两部分,每次从未排序部分选择最小的元素,并将其放入已排序部分的末尾。 ```python def selection_sort(arr): n = len(arr) for i in range(n-1): min_idx = i for j in range(i+1, n): if arr[j] < arr[min_idx]: min_idx = j arr[i], arr[min_idx] = arr[min_idx], arr[i] return arr ``` 3. 插入排序(Insertion Sort): 插入排序是一种简单且高效的排序算法。它将列表分为已排序和未排序两部分,每次从未排序部分选择一个元素,并将其插入到已排序部分的正确位置。 ```python def insertion_sort(arr): n = len(arr) for i in range(1, n): key = arr[i] j = i - 1 while j >= 0 and arr[j] > key: arr[j + 1] = arr[j] j -= 1 arr[j + 1] = key return arr ``` 4. 快速排序(Quick Sort): 快速排序是一种高效的分治排序算法。它选择一个基准元素,将列表分为小于基准值和大于基准值的两部分,然后递归地对这两部分进行排序。 ```python def quick_sort(arr): if len(arr) <= 1: return arr pivot = arr[len(arr) // 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort(left) + middle + quick_sort(right) ``` 5. 归并排序(Merge Sort): 归并排序是一种稳定的排序算法,它采用分治策略将列表分为较小的部分,然后递归地合并这些部分以获得排序结果。 ```python def merge_sort(arr): if len(arr) <= 1: return arr mid = len(arr) // 2 left = arr[:mid] right = arr[mid:] left = merge_sort(left) right = merge_sort(right) return merge(left, right) def merge(left, right): result = [] i, j = 0, 0 while i < len(left) and j < len(right): if left[i] < right[j]: result.append(left[i]) i += 1 else: result.append(right[j]) j += 1 result.extend(left[i:]) result.extend(right[j:]) return result ``` 6. 堆排序(Heap Sort): 堆排序利用堆的性质进行排序。它将列表视为完全二叉树,并使用堆数据结构来选择最大或最小元素并将其放在正确的位置上。 ```python def heapify(arr, n, i): largest = i left = 2 * i + 1 right = 2 * i + 2 if left < n and arr[i] < arr[left]: largest = left if right < n and arr[largest] < arr[right]: largest = right if largest != i: arr[i], arr[largest] = arr[largest], arr[i] heapify(arr, n, largest) def heap_sort(arr): n = len(arr) for i in range(n // 2 - 1, -1, -1): heapify(arr, n, i) for i in range(n - 1, 0, -1): arr[i], arr[0] = arr[0], arr[i] heapify(arr, i, 0) return arr ``` 7. 计数排序(Counting Sort): 计数排序是一种稳定的整数排序算法,它使用额外的计数数组来确定每个元素在排序后的位置。它适用于元素范围较小的情况。 ```python def counting_sort(arr): max_val = max(arr) count = [0] * (max_val + 1) for num in arr: count[num] += 1 sorted_arr = [] for i in range(len(count)): sorted_arr.extend([i] * count[i]) return sorted_arr ``` 8. 桶排序(Bucket Sort): 桶排序是一种将元素分配到

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿熊不会编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值