基数排序

Python

def radixsort(l,num1):
    l1=[[],[],[],[],[],[],[],[],[],[]]
    for x in range(0,num1):
        for y in range(0,len(l)):
            num=getinpos(l[y],x)
            l1[num].append(l[y])
        l=[]
        for y in range(0,10):
            while len(l1[y])!=0:
                l.append(l1[y].pop(0))
    return l

def getinpos(num,pos):
    temp=1
    for x in range(0,pos):
        temp*=10
    return int((num/temp)%10)

C++

#include<stdio.h>
#include<stdlib.h>

#define Max_ 10      //数组个数
#define RADIX_10 10    //整形排序
#define KEYNUM_31 10     //关键字个数，这里为整形位数

// 打印结果
void Show(int  arr[], int n)
{
    int i;
    for ( i=0; i<n; i++ )
        printf("%d  ", arr[i]);
    printf("\n");
}

// 找到num的从低到高的第pos位的数据
int GetNumInPos(int num,int pos)
{
    int temp = 1;
    for (int i = 0; i < pos - 1; i++)
        temp *= 10;

    return (num / temp) % 10;
}


//基数排序  pDataArray 无序数组；iDataNum为无序数据个数
void RadixSort(int* pDataArray, int iDataNum)
{   int i,j;
    int *radixArrays[RADIX_10];    //分别为0~9的序列空间
    for (i = 0; i < 10; i++)
    {
        radixArrays[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));
        radixArrays[i][0] = 0;    //index为0处记录这组数据的个数
    }

    for (int pos = 1; pos <= KEYNUM_31; pos++)    //从个位开始到31位
    {
        for (i = 0; i < iDataNum; i++)    //分配过程
        {
            int num = GetNumInPos(pDataArray[i], pos);
            int index = ++radixArrays[num][0];
            radixArrays[num][index] = pDataArray[i];
        }

        for (i = 0, j =0; i < RADIX_10; i++)    //收集
        {
            for (int k = 1; k <= radixArrays[i][0]; k++)
                pDataArray[j++] = radixArrays[i][k];
            radixArrays[i][0] = 0;    //复位
        }
    }
}

int main()
{   //测试数据
    int arr_test[Max_] = { 8, 4, 2, 3, 5, 1, 6, 9, 0, 7 };
    //排序前数组序列
    Show( arr_test, Max_ );
    RadixSort( arr_test, Max_);
    //排序后数组序列
    Show( arr_test, Max_ );
    return 0;
}

思考：
l=[[]]*10,与l[[],[],[],[]…[]]形成的列表在append上有何不同？

他山之石：
http://blog.youkuaiyun.com/wangxinginnlp/article/details/53201450

#python是个很方便的语言，我经常使用python的*操作符去构建list中的重复元素。例如：
>>> l = [1] * 4
>>> print(l)
>>> [1, 1, 1, 1]
#这样做确实很方便，但也很危险，请先看下面的代码:
>>> l = [{'a': 1}] * 4
>>> print(l)
>>> [{'a': 1}, {'a': 1}, {'a': 1}, {'a': 1}]

>>> l[0]['a'] = 2
>>> print(l)
>>> [{'a': 2}, {'a': 2}, {'a': 2}, {'a': 2}]
#我改了list中的一个dict的值为2， 全部的dict都为2了！！！
#一句话解释就是，*操作符在实现上是复制了值的引用，而不是创建了新的对象。所以上述的list里面，是4个指向同一个dict对象的引用。
#*操作符对于不可变对象很安全，但对于可变对象，可能就不是你期望的结果了。因为不可变对象是复制值，而可变对象是复制引用。
使用以下代码避免问题：
>>> l = [{'a': 1} for _ in range(4)]
>>> print(l)
>>> [{'a': 1}, {'a': 1}, {'a': 1}, {'a': 1}]

>>> l[0]['a'] = 2
>>> print(l)
>>> [{'a': 2}, {'a': 1}, {'a': 1}, {'a': 1}]