基数排序

【0】README

0.1） 本文总结于 数据结构与算法分析，但源代码均为原创；旨在理清 基数排序的具体步骤；
0.2） 要知道， 基数排序 等价于 多次桶排序，所以了解基数排序的前提是了解桶排序，桶排序的详情，参见： http://blog.csdn.net/pacosonswjtu/article/details/49685749
Attention） 基数排序，说白了就是进行多次的桶式排序；

---

【1】算法介绍

1.1）基数排序的思想：“多关键字排序”。
1.2）基数排序有两种实现方式：最高位优先+最低位优先

• 1.2.1）第一种叫做最高位优先：即先按最高位排成若干子序列， 再对每个子序列按次高位来排，以此类推。
  
  • 举个荔枝（扑克牌）： 就是先按花色排成4个子序列， 再对每种花色的13张牌进行排序， 最终使所有扑克牌有序；
• 1.2.2）第二种叫做最低位优先： 这种方式不必分成子序列。每次排序全体元素都参与。
  
  • 举个荔枝（扑克牌）： 可以先按数字将牌分配到13个桶中， 然后从第一个桶开始依次收集； 再将收集好的牌按照花色分配到4个桶中，然后还是从第一个桶开始依次收集，结果两次分配和收集，最终使牌有序；

---

【2】最低位优先的基数排序执行流程

2.1）看个荔枝：

原始序列：110 245 895 658 321 852 147 458 469 159 357 028

2.2）执行流程：每个元素的每一位都是由数字构成， 数字范围0~9； 所以准备10个桶来放元素。要注意， 组成的元素的每一位不一定是数组。如果元素的某一位是扑克牌的花色， 因为花色有4种， 所以在按花色那一位排序时， 要准备4个桶。同样的道理， 如果元素有一位英文字母， 那么按这一位排序， 就要准备26个桶。
Attention）这里说的桶， 其实是一个先进先出的队列（数据从桶的上面进，下面出）；
step1）第一趟分配和收集数据，按照最后一位：

• step1.1）分配数据到桶
  

• step1.2）从桶中收集数据
  按桶0~桶9的顺序收集， 注意数据从桶的下面出；
  将每桶收集的数据依次排开， 所以第【1】趟收集后的结果为： 110, 321, 852, 245, 895, 147, 347, 658, 458, 028, 469, 159 ；

• Result）注意观察， 最低位是有序的， 这就是第1趟基数排序后的结果；

step2）第二趟分配和收集数据，按照次低位（3位数中间那一位）：

• step2.1）分配数据到桶
  

• step2.2）从桶中收集数据
  将每桶收集的数据依次排开， 所以第【2】趟收集后的结果为：110 321 028 245 147 347 852 658 458 159 469 895 ；

• Result）此时， 次低位有序了， 并且次低位相同的那些元素， 其最低位也是有序的，这就是第2趟基数排序后的结果；

step3）第三趟分配和收集数据，按照次次低位（3位数最高那一位）：

• step3.1）分配数据到桶
  

• step3.2）从桶中收集数据
  将每桶收集的数据依次排开， 所以第【3】趟收集后的结果为： 028 110 147 159 245 321 347 458 469 658 852 895

• Result）此时， 次次低位（最高位）有序了， 并且 次次低位相同的那些元素， 其次低位也是有序的；次低位相同的元素，其最低位时有序的， 这就是第3趟基数排序后的结果， 也即整个序列有序， 基数排序过程结束；

---

【3】source code + printing result

3.1）download source code :
https://github.com/pacosonTang/dataStructure-algorithmAnalysis/tree/master/chapter7/radixSort
3.2）source code at a glance：
[1st file : p189_bucketSort.h ]

#include <stdio.h>
#include <malloc.h>

#define MAX 10
#define ElementType int
#define Error(str) printf("\n\t error: %s \n",str) 

struct Node;
typedef struct Node *Node;

Node *initBuckets();
void bucketSort(Node* buckets, ElementType data, int index);
void radixSort(Node* buckets, ElementType* data, int size);
void bucketsToData(Node* buckets, ElementType *data);
void printBuckets(Node* data);
void printArray(ElementType data[], int size);
Node makeEmpty();

struct  Node
{
    int value;
    Node next;
};

[2nd file : p189_bucketSort.c ]

#include "p189_bucketSort.h"

// allocate the memory for the bucket and bucket ptr
Node *initBuckets()
{
    Node* buckets;
    int i;

    buckets = (Node*)malloc(MAX * sizeof(Node));
    if(!buckets)
    {
        Error("out of space, from func bucketSort!");
        return NULL;    
    }   

    for(i=0; i<MAX; i++)    
        buckets[i] = makeEmpty();    
    return buckets;
}

//allocate the memory for the node and make it empty with evaluation of next
Node makeEmpty()
{
    Node temp; 

    temp = (Node)malloc(sizeof(struct Node));
    if(!temp)
    {
        Error("out of space, from func makeEmpty!");
        return NULL;    
    }
    temp->next = NULL;  

    return temp;
}

void bucketsToData(Node* buckets, ElementType *data)
{
    int i;
    int j;
    Node temp;

    i = 0;
    j = 0;
    while(i< MAX) // and now, we update the data array from buckets
    {
        temp = buckets[i]->next;
        while(temp)
        {
            data[j++] = temp->value;
            temp = temp->next;
        }
        i++;
    }
    // updating over    

}

// details of bucketSort for the input array data with size
void bucketSort(Node* buckets, ElementType data, int index)
{           
    Node temp;

    temp = buckets[index];
    while(temp->next)
        temp = temp->next;
    temp->next = makeEmpty();
    temp->next->value = data;
}
void printBuckets(Node* buckets)
{
    int i;
    Node node;

    for(i = 0;i<MAX; i++)
    {   
        if(!buckets[i]->next)
            continue;
        for(node = buckets[i]->next; node != NULL; node = node->next)
            printf("\n\t buckets[%d] = %d", i, node->value);
    }

    printf("\n");
}

void printArray(ElementType data[], int size)
{
    int i;

    for(i = 0; i < size; i++)    
        printf("\n\t data[%d] = %d", i, data[i]);                    
    printf("\n\n");
} 

[3nd file : p189_radixSort.c ]

#include "p189_bucketSort.h"

#define Round 3

ElementType singleBit(ElementType value, int bit)
{
    int i;

    i = 1;
    while(i++ < bit)
        value = value / 10;      
    return value % 10;
} 

//free the memory the buckets own
void clearBuckets(Node* buckets)
{
    int i;
    Node temp;  
    Node tempTwo;

    for(i = 0; i < MAX; i++)
    {
        temp = buckets[i]->next;
        buckets[i]->next = NULL;
        while(temp)
        {
            tempTwo = temp->next;
            free(temp); 
            temp = NULL;
            temp = tempTwo;
        }
    }
}

// proceeding the radix sorting for the array
void radixSort(Node* buckets, ElementType* data, int size)
{
    int i;
    int j;      

    for(i = 1; i <= Round; i++)
    {
        for(j=0; j<size; j++)       
            bucketSort(buckets, data[j], singleBit(data[j],i));
        // coducting bucket sorting for data array over

        bucketsToData(buckets, data);// and now, we update the data array from buckets      
        clearBuckets(buckets);
    }
}


int main()
{   
    int size;
    Node* buckets;
    ElementType data[] = {110, 245, 895, 658, 321, 852, 147, 458, 469, 159, 347, 28};

    printf("\n\t====== test for radix sorting towards the data array ======\n");
    printf("\n\t=== the initial array is as follows ===\n");
    size = 12;
    printArray(data, size);

    buckets = initBuckets();
    printf("\n\t=== the buckets array is as follows ===\n");
    radixSort(buckets, data, size);
    printArray(data, size); 

    //printf("%2d", singleBit(28, 4));

    return 0;
}

3.3）printing result：