计数排序分析

🌽 原理介绍:

计数排序是一种非比较型排序算法，它的原理是对于每个输入的数，确定小于它的数的个数，然后把它放在对应的位置上。因此，计数排序的时间复杂度为 O(n)，适用于数据范围较小的情况。

计数排序的基本步骤如下：

1. 找到数组中的最大值和最小值。
2. 初始化计数数组，记录每个数值出现的次数。
3. 累加计数数组，记录小于等于每个数值的数的个数。(前缀和计算,建议先看基数排序代码注释)
4. 从后往前扫描数组，将每个数值放在它在结果数组中的正确位置上。

 举例: 对数组 [10, 9, 5, 1, 3, 7] 进行计数排序的过程：

1. 找到数组中的最大值和最小值。在这个例子中，最大值是 10，最小值是 1。

2. 初始化计数数组，记录每个数值出现的次数。计数数组的大小为 maxValue - minValue + 1 = 10 - 1 + 1 = 10，初始化后的计数数组为 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]。

3. 扫描一遍数组，记录每个数值出现的次数。最终的计数数组为 [1, 1, 0, 1, 0, 1, 1, 0, 1, 1]。

4. 累加计数数组，记录小于等于每个数值的数的个数。最终的计数数组为 [1, 2, 2, 3, 3, 4, 5, 5, 6, 7]。(此处为前缀和计算)

5. 从后往前扫描数组，将每个数值放在它在结果数组中的正确位置上。最终得到的结果数组为 [1, 3, 5, 7, 9, 10]。(这里不好理解,详见基数排序代码注释,同此处)

所以，计数排序对数组 [10, 9, 5, 1, 3, 7] 进行排序的结果为 [1, 3, 5, 7, 9, 10]。

🌽 特点:

1. 时间复杂度低：计数排序的时间复杂度为 O(n)，是一种线性时间复杂度的排序算法，比较快速。

2. 稳定性好：计数排序是一种稳定的排序算法，也就是说，如果两个数的大小相同，那么它们在排序后的相对位置不会发生变化。

3. 数据范围较小：计数排序适用于数据范围较小的情况，因为它需要开辟一个计数数组，大小为数据范围，如果数据范围较大，那么开辟的计数数组会很大，占用较多的空间。

4. 不适用于大规模数据：由于计数排序需要开辟一个计数数组，如果数据规模较大，那么开辟的计数数组会很大，占用较多的空间，不适用于大规模数据的排序。

🌽 代码示例:

/************************************************************
 * @description: heap sort 
 * @author: kashine
 * @version: 1.0
 * @mail: likaiqinchina@gmail.com
 * @date: 2022/12/31
*************************************************************/

#include <iostream>
#include <vector>

using namespace std;

// 计数排序函数，arr 是待排序数组，result 是排序后的结果数组
void count_sort(const vector<int>& arr, vector<int>& result) {
  // 找到数组中的最大值和最小值
  int minValue = arr[0];
  int maxValue = arr[0];
  for (int i = 1; i < arr.size(); i++) {
    if (arr[i] < minValue) {
      minValue = arr[i];
    } else if (arr[i] > maxValue) {
      maxValue = arr[i];
    }
  }

  // 初始化计数数组，记录每个数值出现的次数
  vector<int> count(maxValue - minValue + 1);
  for (int i = 0; i < arr.size(); i++) {
    count[arr[i] - minValue]++;
  }

  // 累加计数数组，记录小于等于每个数值的数的个数
  for (int i = 1; i < count.size(); i++) {
    count[i] += count[i - 1];
  }

  // 从后往前扫描数组，将每个数值放在它在结果数组中的正确位置上
  for (int i = arr.size() - 1; i >= 0; i--) {
    result[count[arr[i] - minValue] - 1] = arr[i];
    count[arr[i] - minValue]--;
  }
}

void display(vector<int> arr)
{
    for(auto& it : arr)
    {
        cout << it<< " ";
    }
    cout<<endl;
}

int main() {
    vector<int> arr = {3, 6, 5, 2, 1, 4};
    vector<int> result(arr.size());

    display(arr);

    count_sort(arr, result);

    display(result);

    return 0;
}

🌽 算法复杂度:

最好时间复杂度:O(n)

最坏时间复杂度:O(n)

空间复杂度:O(n)