「数组」计数排序|桶排序|基数排序（C++）

Daking-

已于 2024-09-03 23:22:38 修改

阅读量727

点赞数 18

分类专栏：「数组」 # 「数组::排序」文章标签：数据结构 c++ 排序算法算法

于 2024-09-03 23:14:22 首次发布

本文链接：https://blog.csdn.net/dakingffo/article/details/141870719

版权

「数组」同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

「数组::排序」

5 篇文章 0 订阅

订阅专栏

概述

与以前我们遇到的所有排序都不同的是，今天我们介绍的计数排序|桶排序|基数排序是非比较排序。

非比较排序用一种独到的方式来进行排序，但并不进行元素间的比较。
那是怎么排序的呢？

它预先设置了一些已经排好序的辅助空间，将待排序元素发配到其中，然后再依次取出。

简单来说，这种排序只关心元素的绝对特征，而不该关心元素的相对特征。

1.计数排序

思路

利用cnt数组对原数组进行元素统计。

定义长度为待排序数组arr最大元素值+1的辅助数组cnt[]，遍历待排序数组arr[i]，进行cnt[arr[i]]++操作。

意为：cnt[x]记录了原数组中x的出现次数。

将cnt中的数据依次释放回原数组，即完成排序。

复杂度

时间复杂度: O(w)

空间复杂度: O(w)

w：arr中的最大元素值。

看起来效率很高，但真的是这样吗？

事实上，计数排序只能用于稠密的小范围非负整数元素。

一旦arr中的最大值极大且元素分布及其稀疏，都会造成极大量的空间占用和时间占用。

如果元素不能作为cnt数组下标（如负数或浮点数），计数排序都会直接失效。

（你可能会想到用哈希表代替cnt数组，但哈希值的生成也会占用时间，并有可能触发哈希碰撞）

Code

#include <algorithm>
void count_sort(int arr[], int len) {
	int size = *max_element(arr, arr + len) + 1;
	int* cnt=new int[size]();
	for (int i = 0; i < len; i++)cnt[arr[i]]++;
	for (int j = 0, k = 0; j < size; j++)
		while(cnt[j])arr[k++] = cnt[j]--;
	delete[] cnt;
}

2.桶排序

思路

桶排序是优化过的计数排序，它在大范围内进行非比较类排序，小范围内进行比较类排序。

我们知道计数排序的痛点在于数组下标和数据范围。那怎么对此调整优化呢？

你可以认为计数排序也是一种特殊的桶排序，只不过每个桶里都只有一个元素。

桶排序是一类广义概念，它只是对元素进行了范围划分，并以此分装在不同的桶中，保证每个桶都代表一个数据范围，前一个桶的所有元素小于后一个桶的所有元素。在桶里则采用比较型排序（如插入排序），排序后，依次将桶中元素释放回原数组。

一般，我们定义原数组元素最大值为max_limit，最小值为min_limit。

int num_of_buckets = (max_limit - min_limit) / len + 1;
int size_of_bucket = (max_limit - min_limit) / num_of_buckets + 1;

桶数量的计算方式是人为规定，你也可以选择其他的方式计算，或直接使用固定数量，无需纠结。

桶范围的计算方式则是固定的。

*注意*：+1是为了规避整除结果取0。

复杂度

时间复杂度: O(n+n²/k+k)

空间复杂度: O(n)

k：桶数量

复杂度分析：

时间分析：

元素依次入桶，复杂度为n。

桶内排序对n/k个元素进行插入排序，小范围插入排序复杂度为n，n*n/k=n²/k。

各个桶内元素释放回原数组时使用memcpy函数，k个桶的整体复杂度为k。

事实上，桶排序只能用于具有范围概念的元素。

并且，对于我们提供的桶数量计算方式，我们期望桶排序的对象是稠密且均匀的，这样分桶数量几乎可以到达计数排序级别，否则会被动地分出大量空桶。

但是好在桶排序解决了计数排序的最大范围限制和元素类型限制。

Code

#include <algorithm>
#include <vector>
void bucket_sort(int arr[], int len) {
	using bucket = vector<int>;
	int max_limit = *max_element(arr, arr + len);
	int min_limit = *min_element(arr, arr + len);
	int num_of_buckets = (max_limit - min_limit) / len + 1;
	int size_of_bucket = (max_limit - min_limit) / num_of_buckets + 1;
	vector<bucket>buckets(num_of_buckets);
	for (int i = 0; i < len; i++)buckets[(arr[i] - min_limit) / size_of_bucket].push_back(arr[i]);
	for (bucket& b : buckets)insertion_sort(b.data(), b.size());
	int k = 0;
	for (const bucket& b : buckets) {
		memcpy(arr + k, b.data(), b.size() * sizeof(int));
		k += b.size();
	}
}

void insertion_sort(int arr[], int len) {
	for (int i = 1; i < len; i++) {
		int temp = arr[i], j = i - 1;
		for (; j >=0; j--) {
			if (temp<arr[j])arr[j + 1] = arr[j];
			else break;
		}
		arr[j+1] = temp;
	}
}

3.基数排序

思路

基数排序是另一种计数排序的优化方案，它规避了计数排序对稠密小范围数据的要求，但是它对元素类型的要求同样严苛，必须是整数，因为它是基于整数特征实现的算法。

计数排序只有十个桶buckets[10]，表示[0,9]数字，将数据按位统计，即：

先对元素的个位进行计数排序，将个位同为x的元素放入buckets[x]。

将数据释放回原数组，现在所有元素的个位有序；

先对元素的十位进行计数排序，将十位同为x的元素放入buckets[x]，十位为0则放入buckets[0]。

将数据释放回原数组，现在所有元素的十位有序；

...

直到所有元素的最高位有序，则整体有序。

例如：

     i   0    1    2    3    4    5    6
nums[i]  1    22   31   45  671  398   6
按个位排序：
nums[i]  1    31   671  22   45   6   398
         *     *     *   *    *   *     *
按十位排序；
nums[i]  1    6    22   31   45  671  398
                   *    *    *    *    *
按百位排序：
nums[i]  1    6    22   31   45  398  671
                                 *    *

复杂度

时间复杂度: O(n*w)

空间复杂度: O(n)

w：最大元素的数量级+1

事实上，基数排序只能用于整数元素，但不对数据范围有任何要求。

Code

*注意*：理论上，基数排序支持负整数排序，但我们并未在以下code中提供。

#include <algorithm>
void radix_sort(int arr[], int len) {
	using bucket = vector<int>;
	bucket buckets[10];
	int limit = *max_element(arr, arr + len);
	for(int mask=1;mask<limit;mask*=10){
		for (int i = 0; i < len; i++)buckets[arr[i] / mask % 10].push_back(arr[i]);
		for (int j = 0, k = 0; j < 10; j++) {
			memcpy(arr + k, buckets[j].data(), buckets[j].size() * sizeof(int));
			k += buckets[j].size();
			buckets[j].clear();
		}
	}
}