歡迎光臨
每天分享高質量文章

常用排序演算法總結(2)

(點擊上方公眾號,可快速關註)


來源:SteveWang 

http://www.cnblogs.com/eniac12/p/5332117.html

上一篇總結了常用的比較排序演算法,主要有冒泡排序選擇排序插入排序歸併排序堆排序快速排序等。

這篇文章中我們來探討一下常用的非比較排序演算法:計數排序基數排序桶排序。在一定條件下,它們的時間複雜度可以達到O(n)。

這裡我們用到的唯一資料結構就是陣列,當然我們也可以利用鏈表來實現下述演算法。

計數排序(Counting Sort)

計數排序用到一個額外的計數陣列C,根據陣列C來將原陣列A中的元素排到正確的位置。

通俗地理解,例如有10個年齡不同的人,假如統計出有8個人的年齡不比小明大(即小於等於小明的年齡,這裡也包括了小明),那麼小明的年齡就排在第8位,通過這種思想可以確定每個人的位置,也就排好了序。當然,年齡一樣時需要特殊處理(保證穩定性):通過反向填充標的陣列,填充完畢後將對應的數字統計遞減,可以確保計數排序的穩定性。

計數排序的步驟如下:

  1. 統計陣列A中每個值A[i]出現的次數,存入C[A[i]]

  2. 從前向後,使陣列C中的每個值等於其與前一項相加,這樣陣列C[A[i]]就變成了代表陣列A中小於等於A[i]的元素個數

  3. 反向填充標的陣列B:將陣列元素A[i]放在陣列B的第C[A[i]]個位置(下標為C[A[i]] – 1),每放一個元素就將C[A[i]]遞減

計數排序的實現代碼如下:

#include

using namespace std;

 

// 分類 ———— 內部非比較排序

// 資料結構 ——— 陣列

// 最差時間複雜度 —- O(n + k)

// 最優時間複雜度 —- O(n + k)

// 平均時間複雜度 —- O(n + k)

// 所需輔助空間 —— O(n + k)

// 穩定性 ———– 穩定

 

 

const int k = 100;   // 基數為100,排序[0,99]內的整數

int C[k];            // 計數陣列

 

void CountingSort(int A[], int n)

{

    for (int i = 0; i < k; i++)   // 初始化,將陣列C中的元素置0(此步驟可省略,整型陣列元素預設值為0)

    {

        C[i] = 0;

    }

    for (int i = 0; i < n; i++)   // 使C[i]儲存著等於i的元素個數

    {

        C[A[i]]++;

    }

    for (int i = 1; i < k; i++)   // 使C[i]儲存著小於等於i的元素個數,排序後元素i就放在第C[i]個輸出位置上

    {

        C[i] = C[i] + C[i1];

    }

    int *B = (int *)malloc((n) * sizeof(int));// 分配臨時空間,長度為n,用來暫存中間資料

    for (int i = n1; i >= 0; i)    // 從後向前掃描保證計數排序的穩定性(重覆元素相對次序不變)

    {

        B[C[A[i]]] = A[i];      // 把每個元素A[i]放到它在輸出陣列B中的正確位置上

                                  // 當再遇到重覆元素時會被放在當前元素的前一個位置上保證計數排序的穩定性

    }

    for (int i = 0; i < n; i++)   // 把臨時空間B中的資料拷貝回A

    {

        A[i] = B[i];

    }

    free(B);    // 釋放臨時空間

}

 

int main()

{

    int A[] = { 15, 22, 19, 46, 27, 73, 1, 19, 8 };  // 針對計數排序設計的輸入,每一個元素都在[0,100]上且有重覆元素

    int n = sizeof(A) / sizeof(int);

    CountingSort(A, n);

    printf(“計數排序結果:”);

    for (int i = 0; i < n; i++)

    {

        printf(“%d “, A[i]);

    }

    printf(“\n”);

    return 0;

}

下圖給出了對{ 4, 1, 3, 4, 3 }進行計數排序的簡單演示過程

計數排序的時間複雜度和空間複雜度與陣列A的資料範圍(A中元素的最大值與最小值的差加上1)有關,因此對於資料範圍很大的陣列,計數排序需要大量時間和記憶體。

例如:對0到99之間的數字進行排序,計數排序是最好的演算法,然而計數排序並不適合按字母順序排序人名,將計數排序用在基數排序演算法中,能夠更有效的排序資料範圍很大的陣列。

基數排序(Radix Sort)

基數排序的發明可以追溯到1887年赫爾曼·何樂禮在打孔卡片製表機上的貢獻。它是這樣實現的:將所有待比較正整數統一為同樣的數位長度,數位較短的數前面補零。然後,從最低位開始進行基數為10的計數排序,一直到最高位計數排序完後,數列就變成一個有序序列(利用了計數排序的穩定性)。

基數排序的實現代碼如下:

#include

using namespace std;

 

// 分類 ————- 內部非比較排序

// 資料結構 ———- 陣列

// 最差時間複雜度 —- O(n * dn)

// 最優時間複雜度 —- O(n * dn)

// 平均時間複雜度 —- O(n * dn)

// 所需輔助空間 —— O(n * dn)

// 穩定性 ———– 穩定

 

const int dn = 3;                // 待排序的元素為三位數及以下

const int k = 10;                // 基數為10,每一位的數字都是[0,9]內的整數

int C[k];

 

int GetDigit(int x, int d)          // 獲得元素x的第d位數字

{

    int radix[] = { 1, 1, 10, 100 };// 最大為三位數,所以這裡只要到百位就滿足了

    return (x / radix[d]) % 10;

}

 

void CountingSort(int A[], int n, int d)// 依據元素的第d位數字,對A陣列進行計數排序

{

    for (int i = 0; i < k; i++)

    {

        C[i] = 0;

    }

    for (int i = 0; i < n; i++)

    {

        C[GetDigit(A[i], d)]++;

    }

    for (int i = 1; i < k; i++)

    {

        C[i] = C[i] + C[i1];

    }

    int *B = (int*)malloc(n * sizeof(int));

    for (int i = n1; i >= 0; i)

    {

        int dight = GetDigit(A[i], d);  // 元素A[i]當前位數字為dight  

        B[C[dight]] = A[i];           // 根據當前位數字,把每個元素A[i]放到它在輸出陣列B中的正確位置上

        // 當再遇到當前位數字同為dight的元素時,會將其放在當前元素的前一個位置上保證計數排序的穩定性

    }

    for (int i = 0; i < n; i++)

    {

        A[i] = B[i];

    }

    free(B);

}

 

void LsdRadixSort(int A[], int n)     // 最低位優先基數排序

{

    for (int d = 1; d <= dn; d++)     // 從低位到高位

        CountingSort(A, n, d);        // 依據第d位數字對A進行計數排序

}

 

int main()

{

    int A[] = { 20, 90, 64, 289, 998, 365, 852, 123, 789, 456 };// 針對基數排序設計的輸入

    int n = sizeof(A) / sizeof(int);

    LsdRadixSort(A, n);

    printf(“基數排序結果:”);

    for (int i = 0; i < n; i++)

    {

        printf(“%d “, A[i]);

    }

    printf(“\n”);

    return 0;

}

下圖給出了對{ 329, 457, 657, 839, 436, 720, 355 }進行基數排序的簡單演示過程

基數排序的時間複雜度是O(n * dn),其中n是待排序元素個數,dn是數字位數。這個時間複雜度不一定優於O(n log n),dn的大小取決於數字位的選擇(比如比特位數),和待排序資料所屬資料型別的全集的大小;dn決定了進行多少輪處理,而n是每輪處理的運算元目。

如果考慮和比較排序進行對照,基數排序的形式複雜度雖然不一定更小,但由於不進行比較,因此其基本操作的代價較小,而且如果適當的選擇基數,dn一般不大於log n,所以基數排序一般要快過基於比較的排序,比如快速排序。由於整數也可以表達字串(比如名字或日期)和特定格式的浮點數,所以基數排序並不是只能用於整數排序。

桶排序(Bucket Sort)

桶排序也叫箱排序。工作的原理是將陣列元素映射到有限數量個桶里,利用計數排序可以定位桶的邊界,每個桶再各自進行桶內排序(使用其它排序演算法或以遞迴方式繼續使用桶排序)。

桶排序的實現代碼如下:

#include

using namespace std;

 

// 分類 ————- 內部非比較排序

// 資料結構 ——— 陣列

// 最差時間複雜度 —- O(nlogn)或O(n^2),只有一個桶,取決於桶內排序方式

// 最優時間複雜度 —- O(n),每個元素占一個桶

// 平均時間複雜度 —- O(n),保證各個桶內元素個數均勻即可

// 所需輔助空間 —— O(n + bn)

// 穩定性 ———– 穩定

 

/* 本程式用陣列模擬桶 */

const int bn = 5;    // 這裡排序[0,49]的元素,使用5個桶就夠了,也可以根據輸入動態確定桶的數量

int C[bn];           // 計數陣列,存放桶的邊界信息

 

void InsertionSort(int A[], int left, int right)

{

    for (int i = left + 1; i <= right; i++)  // 從第二張牌開始抓,直到最後一張牌

    {

        int get = A[i];

        int j = i1;

        while (j >= left && A[j] > get)

        {

            A[j + 1] = A[j];

            j;

        }

        A[j + 1] = get;

    }

}

 

int MapToBucket(int x)

{

    return x / 10;    // 映射函式f(x),作用相當於快排中的Partition,把大量資料分割成基本有序的資料塊

}

 

void CountingSort(int A[], int n)

{

    for (int i = 0; i < bn; i++)

    {

        C[i] = 0;

    }

    for (int i = 0; i < n; i++)     // 使C[i]儲存著i號桶中元素的個數

    {

        C[MapToBucket(A[i])]++;

    }

    for (int i = 1; i < bn; i++)    // 定位桶邊界:初始時,C[i]-1為i號桶最後一個元素的位置

    {

        C[i] = C[i] + C[i1];

    }

    int *B = (int *)malloc((n) * sizeof(int));

    for (int i = n1; i >= 0; i)// 從後向前掃描保證計數排序的穩定性(重覆元素相對次序不變)

    {

        int b = MapToBucket(A[i]);  // 元素A[i]位於b號桶

        B[C[b]] = A[i];           // 把每個元素A[i]放到它在輸出陣列B中的正確位置上

                                    // 桶的邊界被更新:C[b]為b號桶第一個元素的位置

    }

    for (int i = 0; i < n; i++)

    {

        A[i] = B[i];

    }

    free(B);

}

 

void BucketSort(int A[], int n)

{

    CountingSort(A, n);          // 利用計數排序確定各個桶的邊界(分桶)

    for (int i = 0; i < bn; i++) // 對每一個桶中的元素應用插入排序

    {

        int left = C[i];         // C[i]為i號桶第一個元素的位置

        int right = (i == bn1 ? n1 : C[i + 1]1);// C[i+1]-1為i號桶最後一個元素的位置

        if (left < right)        // 對元素個數大於1的桶進行桶內插入排序

            InsertionSort(A, left, right);

    }

}

 

int main()

{

    int A[] = { 29, 25, 3, 49, 9, 37, 21, 43 };// 針對桶排序設計的輸入

    int n = sizeof(A) / sizeof(int);

    BucketSort(A, n);

    printf(“桶排序結果:”);

    for (int i = 0; i < n; i++)

    {

        printf(“%d “, A[i]);

    }

    printf(“\n”);

    return 0;

}

下圖給出了對{ 29, 25, 3, 49, 9, 37, 21, 43 }進行桶排序的簡單演示過程

桶排序不是比較排序,不受到O(nlogn)下限的影響,它是鴿巢排序的一種歸納結果,當所要排序的陣列值分散均勻的時候,桶排序擁有線性的時間複雜度。

覺得本文有幫助?請分享給更多人

關註「演算法愛好者」,修煉編程內功

赞(0)

分享創造快樂