基数排序

分配排序的基本思想：排序过程无须比较关键字，而是通过“分配”和“收集”过程来实现排序。它们的时间复杂度可达到线性阶：O(n)。

一、两种多关键码排序方法

　　最高位优先法（MSD法）。先按k1排序，将序列分成若干子序列，每个子序列中的记录具有相同的k1值；再按k2排序，将每个子序列分成更小的子序列；然后，对后面的关键码继续同样的排序分成更小的子序列，直到按kd排序分组分成最小的子序列后，最后将各个子序列连接起来，便可得到一个有序的序列。前面介绍的扑克牌先按花色再按面值进行排序的方法就是MSD法
　　最次位优先法（LSD法）。先按kd排序，将序列分成若干子序列，每个子序列中的记录具有相同的kd值；再按kd-1排序，将每个子序列分成更小的子序列；然后，对后面的关键码继续同样的排序分成更小的子序列，直到按k1排序分组分成最小的子序列后，最后将各个子序列连接起来，便可得到一个有序的序列。前面介绍的扑克牌先按面值再按花色进行排序的方法就是LSD法。

二、基于LSD方法的链式基数排序的基本思想

　　“多关键字排序”的思想实现“单关键字排序”。对数字型或字符型的单关键字，可以看作由多个数位或多个字符构成的多关键字，此时可以采用“分配-收集”的方法进行排序，这一过程称作基数排序法，其中每个数字或字符可能的取值个数称为基数。比如，扑克牌的花色基数为4，面值基数为13。在整理扑克牌时，既可以先按花色整理，也可以先按面值整理。按花色整理时，先按红、黑、方、花的顺序分成4摞（分配），再按此顺序再叠放在一起（收集），然后按面值的顺序分成13摞（分配），再按此顺序叠放在一起（收集），如此进行二次分配和收集即可将扑克牌排列有序。
　　　　　　

三、基数排序的实现

代码

    public class RadixNode<T>
    {
        private T data; //数据域
        private RadixNode<T> next; //引用域
        public RadixNode(T val, RadixNode<T> p)
        {
            data = val;
            next = p;
        }
        public RadixNode(RadixNode<T> p)
        {
            next = p;
        }
        public RadixNode(T val)
        {
            data = val;
            next = null;
        }
        public RadixNode()
        {
            data = default(T);
            next = null;
        }
        //数据域属性
        public T Data
        {
            get
            {
                return data;
            }
            set
            {
                data = value;
            }
        }
        //引用域属性
        public RadixNode<T> Next
        {
            get
            {
                return next;
            }
            set
            {
                next = value;
            }
        }
    }

 

代码

    //对顺序列表sqList进行关键字为m位整型值的基数排序
    public void radixSort(SeqList<int> sqList, int n, int m)
    {
        int i, j, k, l, power;
        RadixNode<int> p, q;
        RadixNode<int>[] head = new RadixNode<int>[10];
        power = 1;
        for (i = 0; i < m; i++)
        {
            if (i == 0)
                power = 1;
            else
                power = power * 10;
            for (j = 0; j < 10; j++)
            {
                head[j] = new RadixNode<int>(); ;
            }
            for (l = 0; l < n; l++)
            {
                k = sqList.Data[l] / power - (sqList.Data[l] / (power * 10)) * 10;
                q = new RadixNode<int>();
                q.Data = sqList.Data[l];
                q.Next = null;
                p = head[k].Next;
                if (p == null)
                    head[k].Next = q;
                else
                {
                    while (p.Next != null) p = p.Next;
                    p.Next = q;
                }
            }
            /*按照链的顺序收回各记录*/
            l = 0;
            for (j = 0; j < 10; j++)
            {
                p = head[j].Next;
                while (p != null)
                {
                    sqList.Data[l] = p.Data;
                    l++;
                    p = p.Next;
                }
            }
        }
    }

四、时间复杂度分析

　　时间效率：设待排序列为n个记录，d个关键码，关键码的取值范围为radix，则进行链式基数排序的时间复杂度为O(d(n+radix))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。