计数排序是时间复杂度为 O(n)的算法，空间复杂度为O(n)；算法思想跟散列表哈希hash有些类似，主要是利用一段有序数组计算对应元素的下表个数，然后依次输出有数组元素进行排列。基本计数排序是不稳定算法，但是优化后计数排序是稳定算法。本文主要讲解基本计数排序和优化后计数排序。

使用条件：数组必须是整数或者能全部映射为整数，数组所有元素必须在有限较集中范围；

一、具体实现步骤

1.计算原始数组的最大值max和最小值min范围，然后创建一个长度为max--min+1的排序数组sortArr(max--min+1)；

该数组sortArr目的是计算每个原始数组每个元素的个数

auto minmax = std::minmax_element(nums.begin(), nums.end()); // minmax_element(begin，end)可以输入迭代器而minmax(l,r)不能输入迭代器
int min = *minmax.first;
int max = *minmax.second;
int index = 0;
vector<int> sortArr(max - min + 1, 0); // 创建一段数组用来存储每个元素个数
vector<int> result(nums.size()); // 创建一段数组用来存储每个元素个数

2.遍历原始数组，将原始数组的值作为排序数组sortArr的下标进行计数；

此时原始数组所有元素个数已经计算出来并顺序存放；注意：存储下标的时候需要减去最小值，将原始数组缩放到排序数组范围内。

for (const auto& it : nums) // 遍历原始数组，计算所有元素个数；sortArr下标是元素，值是该元素个数
{sortArr[it - min]++;
}

3.遍历排序数组sortArr，将所有非零的值取出下标作为输出数组元素；

这里注意取出下标的时候需要加上最小值，因为前面存入的时候减了最小值。

for (int i = 0; i < sortArr.size(); ++i) // 遍历有序数组，值为非零则取出排列
{while (sortArr[i]){result[index] = i + min;++index;--sortArr[i];}
}

4.最后返回结果数组或者赋值给原来数组

nums = result;

二、完整代码示例

Sorts.h

#pragma once#include <iostream>
#include <vector>using namespace std;struct Sorts {    void count(vector<int>& nums);    void print(vector<int>& nums);
};

Sorts.cpp

#include "Sorts.h"
#include <algorithm>void Sorts::count(vector<int>& nums)
{if (nums.size() <= 1)return;auto minmax = std::minmax_element(nums.begin(), nums.end()); // minmax_element(begin，end)可以输入迭代器而minmax(l,r)不能输入迭代器int min = *minmax.first;int max = *minmax.second;int index = 0;vector<int> sortArr(max - min + 1, 0); // 创建一段数组用来存储每个元素个数vector<int> result(nums.size()); // 创建一段数组用来存储每个元素个数for (const auto& it : nums) // 遍历原始数组，计算所有元素个数；sortArr下标是元素，值是该元素个数{sortArr[it - min]++;}for (int i = 0; i < sortArr.size(); ++i) // 遍历有序数组，值为非零则取出排列{while (sortArr[i]){result[index] = i + min;++index;--sortArr[i];}}nums = result;
}void Sorts::print(vector<int>& nums)
{for (const auto& it : nums)cout << it << ",";cout << endl;
}

main.cpp

 #include <vector>
#include "Sorts.h"using namespace std;int main()
{vector<int> nums = { 2,0,1,6,8,10,5,99,87,333,2,0,1 };Sorts sorts;sorts.print(nums);sorts.count(nums);sorts.print(nums);return 1;
}

输出结果：

三、优化版计数排序

正常版本的计数排序当有几个相同元素时，会改变原来元素相对位置，是不稳定排序，因此需要优化。

3.1 优化的思路

主要是将排序数组sortArr里非零元素作为权值依次加入到后面元素里。具体示例如下所示：

/*
排序数组sortArr总共弄有334个元素
sortArr: 0 1 2 3 4 5 6 7 8 9 10 ... 87 ... 99 ... 333
count: 2 2 2 0 0 1 1 0 1 0 1 0 1 0 1 0 1

变化后排序数组sortArr(Di == Di-1 + Di-2 : 后面的元素等于前面非零元素之和)

第一次变化
sortArr: 0 1 2 3 4 5 6 7 8 9 10 ... 87 ... 99 ... 333
count: 2 4 2 0 0 1 1 0 1 0 1 0 1 0 1 0 1

第二次变化
sortArr: 0 1 2 3 4 5 6 7 8 9 10 ... 87 ... 99 ... 333
count: 2 4 6 0 0 1 1 0 1 0 1 0 1 0 1 0 1

第三次变化
sortArr: 0 1 2 3 4 5 6 7 8 9 10 ... 87 ... 99 ... 333
count: 2 4 6 6 0 1 1 0 1 0 1 0 1 0 1 0 1

第四次变化
sortArr: 0 1 2 3 4 5 6 7 8 9 10 ... 87 ... 99 ... 333
count: 2 4 6 6 6 1 1 0 1 0 1 0 1 0 1 0 1

第五次变化
sortArr: 0 1 2 3 4 5 6 7 8 9 10 ... 87 ... 99 ... 333
count: 2 4 6 6 0 7 1 0 1 0 1 0 1 0 1 0 1

第六次变化
sortArr: 0 1 2 3 4 5 6 7 8 9 10 ... 87 ... 99 ... 333
count: 2 4 6 6 0 1 8 0 1 0 1 0 1 0 1 0 1

第七次变化
sortArr: 0 1 2 3 4 5 6 7 8 9 10 ... 87 ... 99 ... 333
count: 2 4 6 6 0 1 1 8 1 0 1 0 1 0 1 0 1

...

第三百三十三次变化
sortArr: 0 1 2 3 4 5 6 7 8 9 10 ... 87 ... 99 ... 333
count: 2 4 6 6 6 7 8 8 9 9 10 10 11 11 12 12 13

*/

第333次变化后的排序数组sortArr的值即是输出有序数组的下标，索引即是缩放后的元素。代码实现如下：

for (auto& it : sortArr) // 遍历排序数组，将前面非零元素依次累加到后面
{if (it)tmp += it; // 非零则累加it = tmp; // 变化后元素
}
// 经过上面的变化，此时排序数组sortArr的元素即为初始数组元素排序后的位置

那么问题来了，该如何还原排序后元素呢？

答案很简单，因为变化后排序数组sortArr的值是原始数组nums元素排序后索引下标，所以只需要依次遍历原始数组nums，然后找打对应下标，将该原始数组的元素依次取出排列到有序数组即可，代码实现如下：

for (int i = nums.size(); i > 0; --i) // 逆序遍历原始数组，找到对应位置输出有序数组
{int index = sortArr[nums[i - 1]] - 1; // 找到元素nums[i-1]排序后位置索引；sortArr[ nums[i-1] ]的值表示元素nums[i-1]在有序数组中排第几个位置result[index] = nums[i - 1];sortArr[nums[i - 1]]--; // 排序数组取出一个元素排列后，该元素的值需要减一，即如果下次还命中该相同元素，则往后一位排列
}
nums = result;

3.2 优化计数排序跟基本计数排序主要区别

3.2.1变化后的排序数组sortArr存储的元素值不同

基本计数排序的排序数组sortArr存储的是初始化数组nums每个元素个数，而优化后计数排序sortArr的元素存储的是初始化数组nums排序后的位置（即排序后在第几位）

3.2.2遍历排序数组sortArr取元素方式不一样

基本计数排序主要是依次遍历排序数组sortArr，当其值非零时取元素并且该值减一，而优化计数排序主要是逆向遍历原始数组nums，通过在排序数组sortArr中找到原始数组nums每个元素的下标，而赋值给结果数组result

基本计数排序主要区别：

for (int i = 0; i < sortArr.size(); ++i) // 遍历有序数组，值为非零则取出排列
{while (sortArr[i]){result[index] = i + min;++index;--sortArr[i];}
}
nums = result;

优化计数排序主要区别：

for (auto& it : sortArr) // 遍历排序数组，将前面非零元素依次累加到后面
{if (it)tmp += it; // 非零则累加it = tmp; // 变化后元素
}
// 经过上面的变化，此时排序数组sortArr的元素即为初始数组元素排序后的位置for (int i = nums.size(); i > 0; --i) // 逆序遍历原始数组，找到对应位置输出有序数组
{int index = sortArr[nums[i - 1]] - 1; // 找到元素nums[i-1]排序后位置索引；sortArr[ nums[i-1] ]的值表示元素nums[i-1]在有序数组中排第几个位置result[index] = nums[i - 1];sortArr[nums[i - 1]]--; // 排序数组取出一个元素排列后，该元素的值需要减一，即如果下次还命中该相同元素，则往后一位排列
}
nums = result;

四、优化计数排序完整代码示例