常见的排序算法—— 非比较排序

计数排序

计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用

操作步骤：

• 统计相同元素出现次数

• 根据统计的结果将序列回收到原来的序列中
  

• 代码如下：

基数排序

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

• 最高位优先(Most Significant Digit first)法，简称MSD法：先按k1排序分组，同一组中记录，关键码k1相等，再对各组按k2排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd对各子组排序后。再将各组连接起来，便得到一个有序序列。
• 最低位优先(Least Significant Digit first)法，简称LSD法：先从kd开始排序，再对kd-1进行排序，依次重复，直到对k1排序后便得到一个有序序列。
  
  

代码如下：

//算一个这组数最大是几位数
int GetBitCount(int* array, int size)
{
    int count = 1;
    int radix = 10; //设置的基数
    int i = 0;

    for (i = 0; i < size; i++)
    {
        while (array[i] >= radix)
        {
            count++;
            radix *= 10;
        }
    }
    return count;
}

#if 0
int getdigit(int x, int d)
{
    int a[] = { 1, 1, 10, 100 };   //最大三位数，所以这里只要百位就满足了。  
    return (x / a[d]) % 10;
}
#endif


void RadixSort(int array[], int size)
{
    int bitCount = GetBitCount(array, size);
    int bitIdx = 0;
    int radix = 1;
    int *tmp = (int*)malloc(sizeof(array[0])* size);
    if (NULL == tmp)
    {
        assert(0);

        return;
    }

    //有几位数，就要循环几次
    for (bitIdx = 0; bitIdx < bitCount; ++bitIdx)
    {
        int count[10] = { 0 };
        int i = 0;
        int StartAddr[10] = { 0 };

        //统计每个桶的元素个数
        for (i = 0; i < size; i++)
            count[array[i] / radix % 10]++;

        //统计每个桶的起始地址,这里不是i<size,因为桶的个数是10个。
        for (i = 1; i < 10; i++)
            StartAddr[i] = StartAddr[i - 1] + count[i - 1];

        //将数据放到对应桶中
        for (i = 0; i < size; i++)
        {
            int bucketNo = (array[i] / radix) % 10;
            tmp[StartAddr[bucketNo]] = array[i];
            StartAddr[bucketNo]++;
        }

        //回收数据(按桶编号从小到大，每个桶按先进先出)
        memcpy(array, tmp, sizeof(array[0]) * size);

        radix *= 10;
    }

    free(tmp);
}