（数据结构）非比较排序-计数排序、基数排序的分析与实现

计数排序

思路

1、找出最大值和最小值，并计算出最大最小值的差距范围range
2、新建一个数组，将数据作为其下标，存入该数据的次数
3、将新数组中的次数递减，按顺序重新输入到数组a中

代码实现

//计数排序
void CountSort(int*a, size_t n)
{
    assert(a);
    int min=a[0], max = a[0];
    for (size_t i = 0; i < n; ++i)
    {
        if (a[i] < min)
            min = a[i];
        if (a[i]>max)
            max = a[i];
    }
    int range = max - min + 1;
    int *count = new int[range];
    memset(count, 0, range*sizeof(int));
    for (size_t i = 0; i < n; ++i)
    {
        count[a[i]-min]++;
    }
    size_t index = 0;
    for (size_t i = 0; i < range; ++i)
    {
        while (count[i]--)
        {
            a[index++] = i + min;
        }
    }
}

时间复杂度

• 由计数范围所决定，一般情况下，我们将时间复杂度视为O(N*数据范围)。
• 该算法是一个典型用空间换时间的算法。

基数排序

思路

• 基数排序有LSD 和MSD两种排序，我们这里实现的是LSDSort
  1、首先我们需要计算出数组中最大数的位数digit，以便我们控制后续的循环
  2、我们需要进行digit次循环，而每次循环都将对数组进行一次重新排序
  3、排序按照当前所循环到的位数进行排序，例如，当前digit= 2，即十位，那么我们将排除一切因素，仅由十位数的大小来决定数组的排序
  4、从个位一直循环到最大的位数，由此排序出来的即是顺序数组。
  

代码实现

//计算数组内最大数的位数
int GetDigits(int* a, size_t n)
{
    assert(a);

    int base = 1;
    int digits = 1;
    for (size_t i = 0; i < n; ++i)
    {
        while (a[i] > base)
        {
            digits++;
            base *= 10;
        }
    }
    return digits;
}


//基数排序
void LSDSort(int* a, size_t n)
{
    assert(a);
    //算最大值位数
    int digits = GetDigits(a, n);
    int base = 1;

    //统计个位值数据个数
    for (size_t i = 0; i < digits; ++i)
    {
        int count[10] = { 0 };

        for (size_t i = 0; i < n; ++i)
        {
            int num = (a[i] / base) % 10;
            count[num]++;
        }

        //计算定位数组
        int start[10] = { 0 };
        start[0] = 0;
        for (size_t i = 1; i < 10; ++i)
        {
            start[i] = start[i - 1] + count[i - 1];
        }

        //计算桶数组
        int* bucket = new int[n];
        for (size_t i = 0; i < n; ++i)
        {
            int num = (a[i] / base) % 10;
            int& pos = start[num];
            bucket[pos] = a[i];
            ++pos;
        }
        memcpy(a, bucket, sizeof(int)*n);
        base *= 10;

        delete[] bucket;
    }
}

时间复杂度

0（N * 位数）