常用排序演算法及C常式

　　排序（Sorting）是電腦程式設計中的一個重要而且常用的操作，它的功能是將一個資料元素
的任意序列，重新排列成一個按關鍵字有序的序列。下面介紹最為常用的幾種排序演算法，並進行簡單
地比較分析以及C語言常式。這些C常式都是筆者在學習和工作中慢慢積累起來的，應該說還是有些用
處的。（劉愛貴 / Aiguille.LIU）

1、快速排序演算法
　　快速排序是目前公認的最好排序演算法，是一種基於分治技術的重要排序演算法，演算法時間複雜度為
O(nlog2n)。

/* quicksort.c */
#define MAXSIZE 20
#define LENGTH  11
typedef int SqList;
SqList L[LENGTH]={-1,4,7,9,1,5,3,2,6,8,0};
/*分區函數*/
int   Partition(SqList *L,int low,int high)
{
  int pivotkey,temp;
  L[0]=L[low];
  pivotkey=L[low];
  while(low<high)
  {
     while(low<high&&L[high]>=pivotkey)--high;
     L[low]=L[high];
     while(low<high&&L[low]<=pivotkey)++low;
     L[high]=L[low];
  }
  L[low]=L[0];
  return low;
}
void QSort(SqList *L,int low,int high)
{
   int pivotkey;
   if(low<high)
   {
     pivotkey=Partition(L,low,high);
     QSort(L,low,pivotkey-1);
     QSort(L,pivotkey+1,high);
   }
}
void QuickSort(SqList *L)
{
  QSort(L,1,LENGTH);
}
void Print(SqList *L)
{
   int i;
   for(i=1;i<LENGTH;++i)
    printf("%4d",L[i]);
   printf("/n");
}
main()
{
  Print(L);
  QuickSort(L);
  Print(L);
}

2、堆排序演算法
　　堆排序以堆資料結構為基石，是一種高效的排序演算法。因為有堆這種資料結構以及它操作的高效
實現的特徵，使得找到數列中最大的數字這樣的操作只需要O(1)
的時間複雜度，維護需要logn的時間複雜度。堆排序的平均時間複雜度為O(nlogn)，比快速排序算
法稍差，但堆排序是在位的，不需要額外的儲存空間。

/* heapsort.c */
#define LENGTH 9
typedef int HeapType;
int H[LENGTH]={-1,49,38,65,97,76,13,27,49};
void HeapAdjust(HeapType *H,int s,int m)
{
  int rc,j;
  rc=H[s];
  for(j=s*2;j<=m;j*=2)
  {
    if((j<m)&&(H[j]>H[j+1]))++j;
    if(!(rc>H[j]))break;
    H[s]=H[j];
    s=j;
  }
  H[s]=rc;
}
void HeapSort(HeapType *H)
{
   int i,temp;
   for(i=LENGTH/2;i>0;--i)
     HeapAdjust(H,i,LENGTH);
   for(i=LENGTH;i>1;--i)
   {
     temp=H[1];
     H[1]=H[i];
     H[i]=temp;
     HeapAdjust(H,1,i-1);
   }
}
void Print(HeapType *H)
{
   int i;
   for(i=1;i<LENGTH;++i)
     printf("%8d",H[i]);
   printf("/n");
}
main()
{
   Print(H);
   HeapSort(H);
   Print(H);
   getch();
   clrscr();
}

3、雙向冒泡排序演算法
　　雙向冒泡排序演算法是對單向冒泡排序演算法的改進，它是蠻力法在排序問題上的一個應用。直觀上
來看，雙向冒泡法先讓重的氣泡沉到底下，然後讓輕的氣泡浮上來，然後再讓較大氣泡沉下去，讓較
輕氣泡浮上來，依次反覆，直到排序結束。單向冒泡法時間複雜度為O(n*n)，雙向冒泡法略優，但
時間複雜度也為O (n*n)。

/* bi_bobblesort.c */
int data[10]={4,8,22,79,-2,0,100,13,12,-100};
void Bubble_Sort2(int a[],int n);
void Print(int a[],int n);
main()
{
  Print(data,10);
  Bubble_Sort2(data,10);
  Print(data,10);
}
void Print(int a[],int n)
{
    int i;
    for(i=0;i<n;++i)
     printf("%4d",a[i]);
    printf("/n");
}
void Bubble_Sort2(int a[ ],int n)
{
  int low=0,high=n-1;
  int change=1;
  int i,temp;
  while(low<high&&change)
  {
    change=0;
    for(i=low;i<high;i++)
      if(a[i]>a[i+1])
      {
        /* a[i]<->a[i+1];*/
        temp=a[i];
        a[i]=a[i+1];
        a[i+1]=temp;
        change=1;
      }
    high--;
    for(i=high;i>low;i--)
      if(a[i]<a[i-1])
      {
        /* a[i]<->a[i-1]; */
        temp=a[i];
        a[i]=a[i-1];
        a[i-1]=temp;
        change=1;
      }
    low++;
  }//while
}//Bubble_Sort2

4、希爾排序演算法
　　希爾排序又稱縮小增量排序，屬於插入排序類方法，但在時間效率上比其他插入排序方法有較大
改進。它的基本思想是：先將整個待排序記錄序列分割為若干子序列分別進行直接插入排序，待整個
序列中的記錄“基本有序”時，再對全體記錄進行一次直接插入排序。C語言實現及例子如下：

/* shellsort.c */
void shell_insert(int *l, int dk, int length)
{
  int i, j, sentinel;

  for (i=dk; i<length; ++i) {
    if (l[i] < l[i-dk]) {
       sentinel = l[i];
       for (j=i-dk; j>=0 && sentinel<l[j]; j-=dk)
         l[j+dk] = l[j];
       l[j+dk] = sentinel;
    }
  }
}

void shell_sort(int *l, int dlta[], int t, int length)
{
  int k;

  for (k=0; k<t; ++k) {
    shell_insert(l, dlta[k], length);
  }
}

int main(int argc, char *argv[])
{
  int a[10] = {49, 38, 65, 97, 76, 13, 27, 49, 55, 4};
  int dlta[3] = {5, 3, 1};

  shell_sort(a, dlta, 4, 10);

  int i;
  for (i=0; i<10; ++i)
    printf("%4d", a[i]);
  printf("/n");
}

5、計數排序演算法
　　計數排序的基本思想是，對於每一個元素X，確定出小於X的元素個數，據此直接確定X的輸出位
置。計數排序是穩定的排序演算法，時間複雜度為O(n+k)，需要O(n)輔助儲存空間。C語言實現及例子
如下：

/* countsort.c */
print_array(int *arr, int len)
{
  int i;
  for (i=0; i<len; i++)
    printf("%4d", arr[i]);
  printf("/n");
}

int main()
{
  int i,j, length, k;
  int A[8] = {2,5,3,0,2,3,0,3};
  int B[8] = {0,0,0,0,0,0,0,0};
  int C[6] = {0,0,0,0,0,0};

  length = 8;
  k = 6;

  for (i=0; i<k; i++)
    C[i] = 0;

  for (j=0; j<length; j++)
    C[A[j]]++;

  for (i=1; i<k; i++)
    C[i] = C[i] + C[i-1];

  print_array(C, 6);
  for (j=length-1; j>=0; j--) {
    B[C[A[j]] - 1] = A[j];
    C[A[j]]--;
  }

  print_array(A, length);
  print_array(B, length);
}

6、基數排序演算法
　　基數排序的基本思想是：藉助“分配”和“收集”對單邏輯關鍵字進行排序的一種方法，時間複
雜度為O(d * (n + k))，空間複雜度為O(n +
rd)。藉助d次計數排序可以實現基數排序，C語言實現和例子如下：

/* radixsort.c */
print_array(int *arr, int len)
{
  int i;
  for (i=0; i<len; i++)
    printf("%4d", arr[i]);
  printf("/n");
}

int radix(int x, int d)
{
  int i, y = 1;

  for (i=1; i<d; i++)
    y *= 10;

  y = (x/y) % 10;

  return y;
}

int main()
{
  int i, j, l, length, k, d;
  int A[8] = {329,457,657,839,436,720,355,345};
  int B[8] = {0,0,0,0,0,0,0,0};
  int C[10] = {0,0,0,0,0,0,0,0,0,0};

  length = 8;
  k = 10;
  d = 3;

  print_array(A, length);
  for (l=1; l<=d; l++) {

    for (i=0; i<k; i++)
      C[i] = 0;

    for (j=0; j<length; j++)
      C[radix(A[j],l)]++;

    for (i=1; i<k; i++)
      C[i] = C[i] + C[i-1];

    for (j=length-1; j>=0; j--) {
      B[C[radix(A[j],l)] - 1] = A[j];
      C[radix(A[j],l)]--;
    }

    for (i=0; i<length; i++)
      A[i] = B[i];
    print_array(B, length);
  }
}

7、外部排序－K路平衡歸併排序演算法
　　當輸入資料大小大於記憶體時，需要對資料進行分段排序，然後進行歸併，最終得到整個有序序列
。K路平衡歸併排序演算法，對K個歸併有序資料區段，利用“敗者樹”進行歸併排序。其思想和體育比賽
類似（淘汰制，一個一個淘汰），敗者淘汰，勝者參加下一輪比賽，最終得到冠軍和排名序列。下面
給出了一個5路平衡歸併排序的C語言實現的例子。

/* k_mergesort.c */
#define k 5
#define LEN 10

#define MAXKEY 1000
#define MINKEY -1000

typedef int LoserTree;
typedef int External;

int a[k][LEN]= {{5,15,25,35,45,55,65,75,85,95},
                {7,17,27,37,47,57,67,77,87,97},
                {6,16,26,36,46,56,66,76,86,96},
                {3,13,23,33,43,53,63,73,83,93},
                {4,14,24,34,44,54,64,74,84,94}
               };

void input(External *b, int i)
{
  int x = MAXKEY;
  int j;

  for (j=0; j<LEN; ++j) {
    if(a[i][j]<MAXKEY){
      x = a[i][j];
      a[i][j] = MAXKEY;
      break;
    }
  }
  b[i] = x;
}

void output(int x)
{
  printf("%4d", x);
}

void adjust(LoserTree *ls, External *b, int s)
{
  int t = (s+k)/2;
  int tmp;

  while (t > 0) {
    if (b[s] > b[ls[t]]) {
      tmp = s;
      s = ls[t];
      ls[t] = tmp;
    }
    t = t/2;
  }
  ls[0] = s;
}

void create_losertree(LoserTree *ls, External *b)
{
  int i;

  b[k] = MINKEY;
  for (i=0; i<k; ++i)
    ls[i] = k;

  for (i=k-1; i>=0; --i)
    adjust(ls, b, i);
}

void k_merge(LoserTree *ls, External *b)
{
  int i, q;

  for (i=0; i<k; ++i)
    input(b, i);

  create_losertree(ls, b);

  while (b[ls[0]] != MAXKEY) {
    q = ls[0];
    output(b[q]);
    input(b, q);
    adjust(ls, b, q);
  }
}

int main(int argc, char *argv[])
{
  int ls[k+1], b[k+1];
  k_merge(ls, b);
  printf("/n");
  return 0;
}