计数排序与基数排序

news2024/12/26 23:45:51

计数排序与基数排序

计数排序

计数排序：使用一个数组记录序列中每一个数字出现的次数，将该数组的下标作为实际数据，元素的值作为数据出现的次数。例如对于序列[3,0,1,1,3,3,0,2]，统计的结果为：

0出现的次数：2次
1出现的次数：2次
2出现的次数：1次
3出现的次数：3次

依据出现的次数就可以构建出排序之后的序列

void CountSort(vector<int>& nums) {
    int minNum = nums.front();
    int maxNum = nums.front();
    for (int num : nums) {
        minNum = std::min(minNum, num);
        maxNum = std::max(maxNum, num);
    }
    int helpSize = maxNum - minNum + 1;
    int* help = new int[helpSize] {0};//例如最大值为10，最小值为5，需要开辟的数组大小是10-5+1
    for (int num : nums) {
        help[num - minNum]++;//统计次数
    }
    nums.clear();
    for (int i = 0; i < helpSize; i++) {
        while (help[i]--) {
            nums.push_back(i + minNum);
        }
    }
    delete[] help;
}

计数排序的时间复杂度和空间复杂度

时间复杂度：O(N+max-min)，其中max为数组中的最大元素，min为数组中的最小元素。计数排序需要遍历原数组一趟，得到原数组的最大值和最小值从而决定需要开辟的辅助数组的大小，还需要遍历辅助数组得到有序序列

空间复杂度：O(max-min)，取决于数组中最大值和最小值的差

计数排序适用于数据量很大，但是数据分布比较密集的场景，例如有1亿个数，它们都在[20,1000]范围，此时就可以使用计数排序，与其它排序算法相比（例如快排、冒泡），计数排序是一种非比较排序

基数排序

在计数排序中，对于数据较为分散的场景，所需开辟的额外空间较大，例如序列[1,56,26,9999,7]，若使用计数排序，需要额外开辟一个大小为9999的数组，但是原数组只有5个数需要进行排序，在这种情况下，可以考虑使用基数排序

基数排序也是一种非比较排序，基本思想是：先将原序列按照个位进行排序，在按照十位进行排序……依次类推，直到序列完全有序，以[1,56,26,9999,7]为例，流程如下：

在这里插入图片描述

基数排序的轮数取决于序列中最大值的位数，在进行基数排序时，位数小的数字一定在位数大的数字的前面，例如上图中7虽然在进行第一轮排序完成后处于56的后面，但是当完成第二轮排序后7处于56的前面，因为7的十位为0

如何提取一个数字的个位、十位、百位？

方案一：使用to_string将该数字转化为字符串，依次进行提取

方案二：定义一个offset变量，初始为1，将(num/offset)%10，得到个位，每进行一轮，将offset*10

int num = 3675;
int offset = 1;
int bitNum;
while (bitNum=num / offset) {
    cout << bitNum % 10 << ' ';
    offset *= 10;
}
cout << endl;

基数排序的桶

在进行基数排序时一般使用队列作为基数排序的桶，对10进制数字进行排序就需要准备9个队列

void RadixSortByQueue(vector<int>& nums, int bits, int BASE = 10) {//使用队列作为桶进行基数排序
    //bits表示序列中的最大值的位数
    //BASE表示多少进制
    vector<queue<int>> Queues;
    Queues.resize(BASE);
    int offset = 1;
    for (int offset = 1; bits > 0; bits--, offset *= BASE) {//例如最大值为156，则进行3轮
        for (int num : nums) {
            int bitNum = (num / offset) % BASE;//得到个位/十位/百位……的数
            Queues[bitNum].push(num);
        }
        //按照个位/十位/百位……排好的数已经放入Queues中
        nums.clear();
        for (auto& Queue : Queues) {
            while (!Queue.empty()) {
                nums.push_back(Queue.front());
                Queue.pop();
            }
        }
    }
}

基数排序的优化

前缀数量分区：以序列[1,56,26,9999,7]为例，个位数分别是1,6,6,9,7，可以得到的前缀信息如下

个位数<=1的数据数量:1
个位数<=6的数据数量:3
个位数<=7的数据数量:4
个位数<=9的数据数量:5

那么在每一轮按照特定位进行排序时就不需要使用队列，直接开一个和原始数组等规模的辅助数组help即可，将[1,56,26,9999,7]按照个位进行排序，对于数字7，个位为7，由于个位数<=7的数据数量是4，所以7直接放到help数组中下标为3的位置，此时原序列中的7已经放到help数组中，原序列中个位数<=7的数据数量减少一个，变为3，以此类推，直到原序列中的数据全部按照规则转移到help数组中，此时help数组中的数据就是按照位排序好的数据

void RadixSort(vector<int>& nums, int bits, int BASE = 10) {
    //bits表示序列中的最大值的位数
    //BASE表示多少进制
    int* counts = new int[BASE] {0};
    int* help = new int[nums.size()]{ 0 };
    int offset = 1;
    for (int offset = 1; bits > 0; bits--, offset *= BASE) {
        memset(counts, 0, sizeof(int) * BASE);
        for (int num : nums) {
            int bitNum = (num / offset) % BASE;
            counts[bitNum]++;//先统计个数
        }
        for (int i = 1; i < BASE; i++) {
            counts[i] += counts[i - 1];//统计前缀数量
        }
        for (int i = nums.size() - 1; i >= 0; i--) {
            int bitNum = (nums[i] / offset) % BASE;
            help[--counts[bitNum]] = nums[i];
        }
        memcpy(nums.data(), help, sizeof(int) * nums.size());
    }
    delete[] help;
    delete[] counts;
}

为什么需要从后往前遍历向help数组中填数据？

以[1,99,7]为例，在排个位数时，可以从后往前，也可以从前往后，没有影响，个位数排完之后，得到[1,7,99]，但是在排十位数时，必须从后往前，否则就会打乱1和7的顺序，因为1和7的十位都是0，十位<=0的数的个数是2,7是最后一个十位<=的数，因此在遍历时需要从后往前遍历排到靠后位置.

基数排序的拓展

如果原序列中存在负数，如何进行基数排序？

将原序列中的所有数字加上最小值的绝对值，在进行基数排序，将排完序的结果在减去原来最小值的绝对值。如果存在溢出问题，需要考虑使用long long类型。

void RadixSortContainMinus(vector<int>& nums, int BASE = 10) {
    int minNum = nums[0];
    for (int num : nums) {
        minNum = std::min(minNum, num);
    }
    int maxNum = 0;
    for (int& num : nums) {
        num -= minNum;
        maxNum = std::max(maxNum, num);
    }
    int bits = 1;
    while (maxNum / BASE) {
        bits++;
        maxNum /= BASE;
    }
    RadixSort(nums, bits, BASE);
    for (int& num : nums) {
        num += minNum;
    }
}