排序演算法10——圖解基數排序(次位優先法LSD和主位優先法MSD)
排序演算法1——圖解氣泡排序及其實現(三種方法,基於模板及函式指標)
排序演算法2——圖解簡單選擇排序及其實現
排序演算法3——圖解直接插入排序以及折半(二分)插入排序及其實現
排序演算法4——圖解希爾排序及其實現
排序演算法5——圖解堆排序及其實現
排序演算法6——圖解歸併排序及其遞迴與非遞迴實現
排序演算法7——圖解快速排序以及不同CUTOFF的時間測試
排序演算法8——圖解表排序
排序演算法9——圖解桶排序及其實現
排序演算法10——圖解基數排序(次位優先法LSD和主位優先法MSD)
排序演算法——比較與總結
基數排序的概念
基數排序是桶排序的一種推廣。
給定N個記錄,每個記錄的關鍵字為一整數,取值範圍在0到M之間
之前提到的桶排序是在N遠大於M的情況下使用的。
若如果M比N大很多,這時桶排序就需要M個桶,會造成巨大的空間浪費。
而以R為基數對關鍵字進行分解以後,就只需要R個桶就可以了。
例如:
對於數字826
如果根據基數10來分解,可以得到8、2、6三個關鍵字,
其中8是最主位關鍵字,6是最次位關鍵字
如果根據基數16來分解,可以得到3、3、A三個關鍵字,
其中3是最主位關鍵字,A是最次位關鍵字
次位優先法LSD
對於給定範圍在0-999之間的10個關鍵字
{64,8,216,512,27,729,0,1,343,125}
① 先為最次位關鍵字建立桶(10個),將關鍵字按最次位分別放到10個桶中
② 然後將①中得到的序列按十位放到相應的桶裡
③ 做一次收集,掃描每一個桶,收集到一個連結串列中串起來
④ 將③中得到的序列按最主位放到桶中
⑤ 最後做一次收集,這樣就得到一個有序的序列了
對N個關鍵字用R個桶進行基數排序時,其時間複雜度為
O(D(N+R ))
其中,D為分配收集的次數,也就是關鍵字按基數分解後的位數
當記錄的個數N
與桶的個數R
基本是一個數量級
時,基數排序可以達到線性複雜度
。
基數排序用連結串列實現的好處:不需要將記錄進行物理移動,對於大型記錄的排序是有利的
而代價是:需要O(N)
額外空間存放指標
測試結果及程式碼
1)次位優先法LSD
#include <iostream>
/* 基數排序 - 次位優先 */
/* 假設元素最多有MaxDigit個關鍵字,基數全是同樣的Radix */
#define MaxDigit 4
#define Radix 10
typedef int ElemType;
/* 桶元素結點 */
typedef struct Node *PtrToNode;
struct Node {
int key;
PtrToNode next;
};
/* 桶頭結點 */
struct HeadNode {
PtrToNode head, tail;
};
typedef struct HeadNode Bucket[Radix];
int GetDigit(int X, int D)
{ /* 預設次位D=1, 主位D<=MaxDigit */
int d, i;
for (i = 1; i <= D; i++) {
d = X % Radix;
X /= Radix;
}
return d;
}
void LSDRadixSort(ElemType A[], int N)
{ /* 基數排序 - 次位優先 */
int D, Di, i;
Bucket B;
PtrToNode tmp, p, List = NULL;
for (i = 0; i<Radix; i++) /* 初始化每個桶為空連結串列 */
B[i].head = B[i].tail = NULL;
for (i = 0; i<N; i++) { /* 將原始序列逆序存入初始連結串列List */
tmp = (PtrToNode)malloc(sizeof(struct Node));
tmp->key = A[i];
tmp->next = List;
List = tmp;
}
/* 下面開始排序 */
for (D = 1; D <= MaxDigit; D++) { /* 對資料的每一位迴圈處理 */
/* 下面是分配的過程 */
p = List;
while (p) {
Di = GetDigit(p->key, D); /* 獲得當前元素的當前位數字 */
/* 從List中摘除 */
tmp = p; p = p->next;
/* 插入B[Di]號桶尾 */
tmp->next = NULL;
if (B[Di].head == NULL)
B[Di].head = B[Di].tail = tmp;
else {
B[Di].tail->next = tmp;
B[Di].tail = tmp;
}
}
/* 下面是收集的過程 */
List = NULL;
for (Di = Radix - 1; Di >= 0; Di--) { /* 將每個桶的元素順序收集入List */
if (B[Di].head) { /* 如果桶不為空 */
/* 整桶插入List表頭 */
B[Di].tail->next = List;
List = B[Di].head;
B[Di].head = B[Di].tail = NULL; /* 清空桶 */
}
}
}
/* 將List倒入A[]並釋放空間 */
for (i = 0; i<N; i++) {
tmp = List;
List = List->next;
A[i] = tmp->key;
free(tmp);
}
}
template<class T>
void ArrShow(T *A, int length) {
for (int i = 0; i < length; ++i) {
std::cout << A[i] << " ";
}
puts("\n");
}
int main(int argc, char *argv[]) {
int test[9] = { 1, 2, 11, 66, 53, 53, 54, 16, 4 };
ArrShow(test, 9);
puts("LSDRadixSort : ");
LSDRadixSort(test, 9);
ArrShow(test, 9);
return 0;
}
2)主位優先法MSD
#include <iostream>
/* 基數排序 - 主位優先 */
/* 假設元素最多有MaxDigit個關鍵字,基數全是同樣的Radix */
#define MaxDigit 4
#define Radix 10
typedef int ElemType;
/* 桶元素結點 */
typedef struct Node *PtrToNode;
struct Node{
int key;
PtrToNode next;
};
/* 桶頭結點 */
struct HeadNode {
PtrToNode head, tail;
};
typedef struct HeadNode Bucket[Radix];
int GetDigit(int X, int D)
{ /* 預設次位D=1, 主位D<=MaxDigit */
int d, i;
for (i = 1; i <= D; i++) {
d = X%Radix;
X /= Radix;
}
return d;
}
void MSD(ElemType A[], int L, int R, int D)
{ /* 核心遞迴函式: 對A[L]...A[R]的第D位數進行排序 */
int Di, i, j;
Bucket B;
PtrToNode tmp, p, List = NULL;
if (D == 0) return; /* 遞迴終止條件 */
for (i = 0; i<Radix; i++) /* 初始化每個桶為空連結串列 */
B[i].head = B[i].tail = NULL;
for (i = L; i <= R; i++) { /* 將原始序列逆序存入初始連結串列List */
tmp = (PtrToNode)malloc(sizeof(struct Node));
tmp->key = A[i];
tmp->next = List;
List = tmp;
}
/* 下面是分配的過程 */
p = List;
while (p) {
Di = GetDigit(p->key, D); /* 獲得當前元素的當前位數字 */
/* 從List中摘除 */
tmp = p; p = p->next;
/* 插入B[Di]號桶 */
if (B[Di].head == NULL) B[Di].tail = tmp;
tmp->next = B[Di].head;
B[Di].head = tmp;
}
/* 下面是收集的過程 */
i = j = L; /* i, j記錄當前要處理的A[]的左右端下標 */
for (Di = 0; Di<Radix; Di++) { /* 對於每個桶 */
if (B[Di].head) { /* 將非空的桶整桶倒入A[], 遞迴排序 */
p = B[Di].head;
while (p) {
tmp = p;
p = p->next;
A[j++] = tmp->key;
free(tmp);
}
/* 遞迴對該桶資料排序, 位數減1 */
MSD(A, i, j - 1, D - 1);
i = j; /* 為下一個桶對應的A[]左端 */
}
}
}
void MSDRadixSort(ElemType A[], int N)
{ /* 統一介面 */
MSD(A, 0, N - 1, MaxDigit);
}
template<class T>
void ArrShow(T *A, int length) {
for (int i = 0; i < length; ++i) {
std::cout << A[i] << " ";
}
puts("\n");
}
int main(int argc, char *argv[]) {
int test[9] = { 1, 2, 11, 66, 53, 53, 54, 16, 4 };
ArrShow(test, 9);
puts("MSDRadixSort : ");
MSDRadixSort(test, 9);
ArrShow(test, 9);
return 0;
}