排序算法----基數排序（RadixSort（L））單鏈表智能版本

轉載http://blog.csdn.net/Shayabean_/article/details/44885917博客

先說說基數排序的思想：   

基數排序是非比較型的排序算法，其原理是將整數按位數切割成不同的數字，然后按每個位數分別比較。

將所有待比較數值（正整數）統一為同樣的數位長度，數位較短的數前面補零。然后，從最低位開始，依次進行一次排序。在每一次排序中，按照當前位把數組元素放到對應        

的桶當中，然后把桶0到桶9中的元素按先進先出的方式放回數組中。這樣從最低位排序一直到最高位排序完成以后, 數列就變成一個有序序列。

 

這個智能版本的基數排序RadixSort（L）較之前的RadixSort（L，max）不同的是不需要輸入待排序列最大數的位數。因為最大數位在程序中已經計算過了，但是因為需要計算最大數，所以需要對待排鏈表最開始循環一次，RadixSort（L，max）速度比RadixSort（L）稍快。

這篇博客包括4個文件，兩個頭文件RadixSort.h和fatal.h，一個庫函數RadixSort.c，和一個測試文件Test_Radix_Sort.c

頭文件fatal.h:

#include<stdio.h>
#include<stdlib.h>
#define Error(Str) FatalError(Str)
#define FatalError(Str) fprintf(stderr, "%s\n", Str), exit(1);

頭文件RadixSort.h：

 

typedef int ElementType;
#ifndef RADIX_SORT_H
#define RADIX_SORT_H

#include<stdbool.h>
#include<assert.h>
#define ListEmpty -2

struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;

List MakeEmpty(List L);
bool IsEmpty(List L);
bool IsLast(Position P, List L);
Position Header(List L);
Position Advance(Position P);
ElementType Retrieve(Position P);
void DeleteList(List L);
void PrintList(const List L);
ElementType Max_LinkedList(List L);//獲取鏈表的最大值
int Get_Num_Length(ElementType Num);//獲取某個數的位數
void Insert(ElementType X, List L, Position P);
void MoveNode(List L1, List L2);//將表L2中的頭節點移動成為L1的尾節點
void RadixSort(List L);//最終基數排序函數，輸入鏈表L，將L排序得到新的排序鏈表L
#endif // !RADIX_SORT_H

 

其中RadixSort是最終排序函數，調用它即可排序。

庫函數RadixSort.c

 

#include "RadixSort.h"
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<math.h>
#include"fatal.h"

//定義結構體
struct Node
{
    ElementType Element;
    Position Next;
};

//初始化鏈表
List MakeEmpty(List L)
{
    if (L != NULL)
        DeleteList(L);//如果鏈表非空，則刪除鏈表
    L = malloc(sizeof(struct Node));
    if (L == NULL)
        FatalError("Out of memory!");
    L->Next = NULL;
    return L;
}
//判斷鏈表是否為空
bool IsEmpty(List L)
{
    return L->Next == NULL;
}

//判斷當前指針P是否指向鏈表最后一個元素
bool IsLast(Position P, List L)
{
    return P->Next == NULL;
}

//獲取鏈表頭
Position Header(List L)
{
    return L;
}

//獲取位置P的下一個位置
Position Advance(Position P)
{
    return P->Next;
}

//提取位置P處結構里面的值
ElementType Retrieve(Position P)
{
    return P->Element;
}

//刪除鏈表
void DeleteList(List L)
{
    Position P, Temp;
    P = L->Next;
    L->Next = NULL;
    while (P != NULL)
    {
        Temp = P->Next;
        free(P);
        P = Temp;
    }
}

//打印鏈表
void PrintList(const List L)
{
    Position P = Header(L);
    if (IsEmpty(L))
        printf("Empty list\n");
    else
    {
        do
        {
            P = Advance(P);
            printf("%d ", Retrieve(P));
        } while (!IsLast(P, L));
        printf("\n");
    }
}

//獲取鏈表的最大值
ElementType Max_LinkedList(List L)
{
    if (IsEmpty(L))
        Error("Empty List")
    else
    {
        Position P = L->Next;
        ElementType Max = P->Element;
        while (P != NULL)
        {
            if (P->Element > Max)
                Max = P->Element;
            P = P->Next;
        }
        return Max;
    }
}

//計算一個數有多少位
int Get_Num_Length(ElementType Num)
{
    int Length=1;
    while ((Num /= 10) != 0) Length++;
    return Length;
}

//插入元素X到位置P后面
void Insert(ElementType X, List L, Position P)
{
    Position  TmpCell;
    TmpCell = malloc(sizeof(struct Node));
    if (TmpCell == NULL)
        FatalError("Out of Space!!!");
    TmpCell->Element = X;
    TmpCell->Next = P->Next;
    P->Next = TmpCell;
}

void MoveNode(List L1, List L2)
{
    //將表L2中的頭節點移動成為L1的尾節點 
    Position Tmp1 = L1;
    Position Tmp2;
    if (IsEmpty(L2)) exit(ListEmpty);
    while (!IsLast(Tmp1,L1))
        Tmp1 = Tmp1->Next;//使Tmp1指向L1表尾 
    Tmp2 = L2->Next;
    L2->Next = Tmp2->Next;
    Tmp1->Next = Tmp2;
    Tmp2->Next = NULL;    
}

//基數排序核心代碼
void RadixSort(List L)
{
    int i,j,Max_Length, TmpSub;//Tmpsub存儲數的個位、十位、百位
    ElementType FirstElement;//存儲鏈表的第一個元素
    Max_Length = Get_Num_Length(Max_LinkedList(L));
    List Bucket[10];//開辟10個桶，依次為0~9
    for (i = 0; i < 10; i++) Bucket[i] = MakeEmpty(NULL);//對10桶進行初始化，每一個數組都是一個鏈表
    for (i = 0; i < Max_Length; i++)//開始提取每一位數的個位、十位、百位
    {
        while (!IsEmpty(L))//當L中的元素被取光了，則循環結束
        {
            FirstElement = L->Next->Element;//取出第一個節點的數據
            TmpSub = (int)(FirstElement / pow(10, i)) % 10;//依次取出個十百位數字 
            MoveNode(Bucket[TmpSub], L);//將L中的節點依次移到對應的桶中
        }
        for (j = 0; j < 10; j++)    //將桶中的數再次移動到L中
        {
            while (!IsEmpty(Bucket[j])) MoveNode(L, Bucket[j]);
        }
    }
    for (i = 0; i < 10; i++) free(Bucket[i]) ;//釋放掉10個桶
}

 

測試函數Test_Radix_Sort.c

#include<stdio.h>
#include "RadixSort.h"
#include"fatal.h"
#include<time.h>

int main()
{
    int  amount;
    List L; Position P;
    L = MakeEmpty(NULL);//初始化鏈表
    P = L;
    if (L == NULL) Error("Out of Space!!!");
    printf("隨機生成多少位數:");
    scanf_s("%d", &amount);
    srand((unsigned)time(NULL));
    for (int i = 0; i < amount; i++)
    {
        Insert(rand()%10000, L, P);
            P = Advance(P);
    }
    printf("排序前的結果：");
    PrintList(L);
    RadixSort(L);//調用排序函數排序
    printf("基數排序后的結果：");
    PrintList(L);
}