居然在不伤元气的情况下写出了基数排序-）

基数排序就不多说了，其思路如下：

0. 输入为n个整数，每个数字为b位

1. 把整数拆分为b/r“位”， 每个"位"的长度为r（十进制长度）

2. 由低到高分别对每个“位”作计数排序

 

值得一说的是，为使算法效率最高，r应该为lgn（取整），然而实现中没有限定r的大小，可以自行设定。

 

不多说，上代码：（RadixSort.h省略）

 

1. RadixSort.cpp

#include "stdafx.h"
#include <malloc.h>
#include <math.h>

void RadixSort(int a[], int length, int digit, int minBit)
{
    //int r = log2((double)length);
    int r = minBit;
    int range = pow(10.0, r);
    int* bucket = (int*)malloc(range * sizeof(int));
    int* count = (int*)malloc(range * sizeof(int));
    for (int i = r - 1; i < digit; i += r)
    {
        int modNum = pow(10.0, i + 1);
        int lastModNum = pow(10.0, i + 1 - r);
        for (int j = 0; j < range; j++)
        {
            count[j] = 0;
            bucket[j] = 0;
        }
        for (int k = 0; k < length; k++)
        {
            if (i - r < 0)
            {
                count[a[k] % modNum]++;
            }
            else
            {
                int temp = (a[k] % modNum - a[k] % lastModNum) / lastModNum;
                count[temp]++;
            }
            
        }
        for (int j = 1; j < range; j++)
        {
            count[j] += count[j - 1];
        }
        for (int k = length - 1; k >= 0; k--)
        {
            if (i - r < 0)
            {
                bucket[count[a[k] % modNum] - 1] = a[k];
                count[a[k] % modNum]--;
            }
            else
            {
                int temp = (a[k] % modNum - a[k] % lastModNum) / lastModNum;
                bucket[count[temp] - 1] = a[k];
                count[temp]--;
            }
        }
        for (int k = 0; k < length; k++)
        {
            a[k] = bucket[k];
        }
        printf("round %d\n", i);
        for (int i = 0; i < length; i++)
        {
            printf("%d\t", a[i]);
        }
        printf("\n");

    }
}

 

2. Main.cpp

// Main.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "RadixSort.h"


int _tmain(int argc, _TCHAR* argv[])
{
    int a[] = { 4343, 1212, 5353, 4141, 8080, 303, 9999 };
    int length = sizeof(a) / sizeof(int);
    RadixSort(a, length, 4, 1);
    return 0;
}

虽然算法还是渣水平，还是要靠单步debug修正代码，还是对0/1的下标犯迷糊，不过能写出这样的代码，比起以前的自己来说是一个巨大的胜利！