排序演算法

引言

在我的博文《“主宰世界”的10種演算法短評》中給出的首個演算法就是高效的排序演算法。本文將對排序演算法做一個全面的梳理，從最簡單的“冒泡”到高效的堆排序等。

排序相關的的基本概念

• 排序：將一組雜亂無章的資料按一定的規律順次排列起來。
  
  • 資料表( data list): 它是待排序資料物件的有限集合。
  • 排序碼(key):通常資料物件有多個屬性域，即多個數據成員組成,其中有一個屬性域可用來區分物件,作為排序依據。該域即為排序碼。每個資料表用哪個屬性域作為排序碼，要視具體的應用需要而定。
• 分類
  
  • 內排序：指在排序期間資料物件全部存放在記憶體的排序；
  • 外排序
    ：指在排序期間全部物件個數太多，不能同時存放在記憶體，必須根據排序過程的要求，不斷在內、外存之間移動的排序。

排序演算法的分析

排序演算法的穩定性

如果在物件序列中有兩個物件r[i]和r[j] ,它們的排序碼k[i]==k[j] 。如果排序前後,物件r[i]和r[j] 的相對位置不變，則稱排序演算法是穩定的；否則排序演算法是不穩定的。

排序演算法的評價

時間開銷

• 排序的時間開銷可用演算法執行中的資料比較次數與資料移動次數來衡量。
• 演算法執行時間代價的大略估算一般都按平均情況進行估算。對於那些受物件排序碼序列初始排列及物件個數影響較大的，需要按最好情況和最壞情況
  進行估算

空間開銷

演算法執行時所需的附加儲存。

插入排序(Insert Sorting)

基本思想

每步將一個待排序的物件,按其排序碼大小,插入到前面已經排好序的一組物件的適當位置上,直到物件全部插入為止。

分類

根據尋找插入位置方法分為

• 直接插入排序
• 折半（二分）插入排序
• 希爾插入排序

直接插入排序

基本思想

當插入第i(i≥1)個物件時,前面的V[0],V[1],…,V[i−1]已經排好序。這時,用V[i]的排序碼與V[i−1],V[i−2],…,V[0]的排序碼順序進行比較,找到插入位置即將V[i]插入,原來位置上的物件向後順移。

直接插入排序圖示

從上到下，分別展示了直接排序演算法的所有可能的過程，包括相同排序碼的排序方式（保持了原來的順序，說明是穩定排序）以及in-place操作中的元素移動等。

直接插入排序演算法分析

設待排序物件個數為n,則該演算法的主程式執行n−1趟排序碼比較次數和物件移動次數與物件排序碼的初始排列有關。

• 最好情況下,排序前物件已經按照要求的有序。比較次數(KCN):n−1 ; 移動次數(RMN):為0。則對應的時間複雜度為O(n)。
• 最壞情況下,排序前物件為要求的順序的反序。第i趟時第i個物件必須與前面i個物件都做排序碼比較,並且每做1次比較就要做1次資料移動（具體可以從下面給出的程式碼中看出）。比較次數(KCN):∑n−1i=1i=n(n−1)2≈n22 ; 移動次數(RMN):為∑n−1i=1i=n(n−1)2≈n22。則對應的時間複雜度為O(n2)。
• 如果排序記錄是隨機的，那麼根據概率相同的原則，在平均情況下的排序碼比較次數和物件移動次數約為n24，因此，直接插入排序的時間複雜度為O(n2)。

直接插入排序演算法的特點

• 它是穩定排序，不改變相同元素原來的順序。
• 它是in-place排序，只需要O(1)的額外記憶體空間。
• 它是線上排序，可以邊接收資料邊排序。
• 它跟我們牌撲克牌的方式相似。
• 對小資料集是有效的。

To save memory, most implementations use an in-place sort that works by moving the current item past the already sorted items and repeatedly swapping it with the preceding item until it is in place.

直接排序的程式碼（C++版本）

虛擬碼如下：

for i = 1, n
j = i
while(j > 0 and E[j] < E[j-1])
     swap(E[j], E[j-1])
     j--

C++程式碼

#include <iostream>
#include <iomanip>

using namespace std;

void swap(int &x, int &y)
{
    int temp = x;
    x = y;
    y = temp;
}

void insertion(int a[], int sz)
{
    for(int i=1; i  < sz; i++) {
        int j = i;
        while(j > 0 && (a[j] < a[j-1])) {
            swap(a[j], a[j-1]);
            j--;
        }
        cout << endl;
        for (int k = 0; k < sz; k++) cout << setw(3) << a[k];
    }
}

int main()
{
    int a[] = { 15, 9, 8, 1, 4, 11, 7, 12, 13, 6, 5, 3, 16, 2, 10, 14};
    int size = sizeof(a)/sizeof(int);
    for (int i = 0; i < size; i++) cout << setw(3) << a[i];
    insertion(a, size);
    cout << endl;
    return 0;
}

過程輸出：

15  9  8  1  4 11  7 12 13  6  5  3 16  2 10 14 

  9 15  8  1  4 11  7 12 13  6  5  3 16  2 10 14 

  8  9 15  1  4 11  7 12 13  6  5  3 16  2 10 14 

  1  8  9 15  4 11  7 12 13  6  5  3 16  2 10 14 

  1  4  8  9 15 11  7 12 13  6  5  3 16  2 10 14 

  1  4  8  9 11 15  7 12 13  6  5  3 16  2 10 14 

  1  4  7  8  9 11 15 12 13  6  5  3 16  2 10 14 

  1  4  7  8  9 11 12 15 13  6  5  3 16  2 10 14 

  1  4  7  8  9 11 12 13 15  6  5  3 16  2 10 14 

  1  4  6  7  8  9 11 12 13 15  5  3 16  2 10 14 

  1  4  5  6  7  8  9 11 12 13 15  3 16  2 10 14 

  1  3  4  5  6  7  8  9 11 12 13 15 16  2 10 14 

  1  3  4  5  6  7  8  9 11 12 13 15 16  2 10 14 

  1  2  3  4  5  6  7  8  9 11 12 13 15 16 10 14 

  1  2  3  4  5  6  7  8  9 10 11 12 13 15 16 14 

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 

下面是使用連結串列的直接插入排序演算法：

#include <iostream>

using namespace std;

struct List
{
    int data;
    struct List *next;
} ;

void printList(struct List *head)
{
    struct List* ptr = head;
    while(ptr) {
        cout << ptr->data << " " ;
        ptr = ptr->next;
    }
    cout << endl;
}

struct List* createList(int a[], int sz)
{
    struct List *head = new struct List;
    struct List *current = head;

    for(int i = 0; i < sz; i++) {
        current->data = a[i];
        if (i == sz - 1 ) {
            current->next = NULL;
            break;
        }
        current->next = new struct List;
        current = current->next;
    }

    return head;
}

struct List* insertion(struct List *head)
  {
      if(head == 0) return head;

      // unsorted list - from the 2nd element
      struct List *unsorted = head->next;
      while(unsorted != 0)
      {
          // take key as an element in the unsorted list.
          struct List *prev = 0;
          struct List *iter = head;
          struct List *key = unsorted;

          // iterate within the sorted list and find the position
          while(iter != 0)
          {
              if(iter->data < key->data)
              {
                  prev = iter;
                  iter = iter->next;
              }
               else
                  break;
          }
          unsorted = unsorted->next;
          // if reached the end of sorted list 
          if(iter == key) 
              continue;

          // note down the position to replace in a sorted list
          struct List *replace = iter;

          //move iter to end of the sorted list 
          while(iter->next != key) iter=iter->next;

          // link to the upsorted list
          iter->next = unsorted;

          // delete the key and replace it in sorted list
          if(prev == 0) {
              head = key;
          } else {
                prev->next = key;
          }
          key->next = replace;
          printList(head);
       }
       return head;
  }

int main()
{
    int a[] = { 15, 9, 8, 1, 4, 11, 7, 12, 13, 6, 5, 3, 16, 2, 10, 14};
    int size = sizeof(a)/sizeof(int);

    struct List *head = createList(a, size);
    printList(head);
    head = insertion(head);
    printList(head);

    cout << endl;
    return 0;
}

未完待續

2015-9-23 藝少