C語言實現(xiàn)排序算法之歸并排序詳解

更新時間：2014年07月19日 10:50:59 投稿：shichen2014

這篇文章主要介紹了C語言實現(xiàn)排序算法之歸并排序,對歸并排序的原理及實現(xiàn)過程做了非常詳細的解讀,需要的朋友可以參考下

排序算法中的歸并排序(Merge Sort)是利用"歸并"技術來進行排序。歸并是指將若干個已排序的子文件合并成一個有序的文件。

一、實現(xiàn)原理：

1、算法基本思路

設兩個有序的子文件(相當于輸入堆)放在同一向量中相鄰的位置上：R[low..m]，R[m+1..high]，先將它們合并到一個局部的暫存向量R1(相當于輸出堆)中，待合并完成后將R1復制回R[low..high]中。

（1）合并過程

合并過程中，設置i，j和p三個指針，其初值分別指向這三個記錄區(qū)的起始位置。合并時依次比較R[i]和R[j]的關鍵字，取關鍵字較小的記錄復制到R1[p]中，然后將被復制記錄的指針i或j加1，以及指向復制位置的指針p加1。
重復這一過程直至兩個輸入的子文件有一個已全部復制完畢(不妨稱其為空)，此時將另一非空的子文件中剩余記錄依次復制到R1中即可。
最后，將結(jié)果賦值的R[]中。

（2）動態(tài)申請R1

實現(xiàn)時，R1是動態(tài)申請的，因為申請的空間可能很大，故須加入申請空間是否成功的處理。

二、3種方法實現(xiàn)：

算法1：歸并函數(shù)都動態(tài)分配一個數(shù)組，兩個有序數(shù)組合并成一個有序數(shù)組

//合并將兩個有序序列（[low,mid],[mid+1,high]）合并
void Merge(int arr[],int low,int mid,int high)
{
  int i=low,j=mid+1,p=0;

  int *newarr = (int *)malloc((high-low+1)*sizeof(int));//用來暫存排序好的數(shù)據(jù)
  if(!newarr){
    printf("malloc error!\n");
    exit(1);
  }

  while(i<=mid && j<=high){    //以下過程很類似兩個有序字符串合并成一個有序字符串
    if(arr[i] < arr[j])
      newarr[p++] = arr[i++];
    else
      newarr[p++] = arr[j++];
  }

  while(i<=mid)
    newarr[p++] = arr[i++];
  while(j<=high)
    newarr[p++] = arr[j++];

  for(i=low,p=0;p<(high-low+1);i++,p++)  //將結(jié)果復制到原數(shù)組當中
    arr[i] = newarr[p];
  free(newarr);
}

算法2：

程序開始處就動態(tài)分配一個大數(shù)組，避免每次都要創(chuàng)建很多小數(shù)組，釋放內(nèi)存的時候，不會立即釋放。

有關assert()參見：http://chabaoo.cn/article/39685.htm

/*
 * File: mergesort.c
 * Time: 2014-07-19 HJJ
 */
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

static void merge1(int array[], int tmp[], int lpos, int rpos, int rend);
static void msort1(int array[], int tmp[], int left, int right);

void merge_sort1(int array[], int n)
{
 assert(array!=NULL && n>1); //條件不滿足，退出程序并打印錯誤語句。

 int *tmp = (int *)malloc(sizeof(int) * n);
 assert(tmp != NULL);
 int i;
 for (i = 0; i < n; i ++) {
 tmp[i] = array[i];
 }
 msort1(array, tmp, 0, n-1);

 free(tmp);
}

//遞歸的調(diào)用此函數(shù)，實現(xiàn)折半劃分，只完成劃分，不實現(xiàn)排序，最終返回array[]數(shù)組有序
static void msort1(int array[], int tmp[], int left, int right)
{
 assert(array!=NULL && tmp!=NULL);

 if (left == right)
 return;

 int center = (left + right) / 2;
 msort1(tmp, array, left, center);
 msort1(tmp, array, center+1, right);
 merge1(tmp, array, left, center+1, right);
}

//該函數(shù)實現(xiàn)，將array[]的左右兩半排好序的數(shù)組，歸并為tmp[]，并排序
static void merge1(int array[], int tmp[], int lpos, int rpos, int rend)
{
 assert(array!=NULL && tmp!=NULL);

 int lend = rpos - 1;
 int tmp_pos = lpos;

 while (lpos<=lend && rpos<=rend) {
 if (array[lpos] <= array[rpos])
  tmp[tmp_pos++] = array[lpos++];
 else
  tmp[tmp_pos++] = array[rpos++];
 }

 while (lpos <= lend)
 tmp[tmp_pos++] = array[lpos++];
 while (rpos <= rend)
 tmp[tmp_pos++] = array[rpos++];
}

int main(int argc, char *argv[])
{
  int a[7] = {6, 5, 4, 3, 2, 1, 7};

  merge_sort1(a, 7);
  int i;
  for (i = 0; i < 7; i ++) {
    printf("%3d", a[i]);
  }
  printf("\n");

  return 0;
}

算法3：
程序開始處分配一個大的數(shù)組，只是每次用array[]將數(shù)據(jù)給tmp[]排好序后，最后再將tmp[]給array[]賦值，這樣就能完成每次調(diào)用的時候，入口都一樣。

void merge_sort1(int array[], int n)
{
 assert(array!=NULL && n>1); //條件不滿足，退出程序并打印錯誤語句。

 int *tmp = (int *)malloc(sizeof(int) * n);
 assert(tmp != NULL);
 int i;
 for (i = 0; i < n; i ++) {
 tmp[i] = array[i];
 }
 msort1(array, tmp, 0, n-1);

 free(tmp);
}

//遞歸的調(diào)用此函數(shù)，實現(xiàn)折半劃分，只完成劃分，不實現(xiàn)排序，最終返回array[]數(shù)組有序
static void msort1(int array[], int tmp[], int left, int right)
{
 assert(array!=NULL && tmp!=NULL);

 if (left == right)
 return;

 int center = (left + right) / 2;
 msort1(tmp, array, left, center);
 msort1(tmp, array, center+1, right);
 merge(tmp, array, left, center+1, right);
}

實現(xiàn)方法二：

void merge(int array[],int tmp[],int lpos,int rpos,int rend)
{
  int i,leftend,num,tmppos;

  leftend = rpos - 1;
  num = rend - lpos + 1;
  tmppos = lpos;

  while(lpos <= leftend && rpos <= rend){
    if(array[lpos] <= array[rpos])
      tmp[tmppos++] = array[lpos++];
    else
      tmp[tmppos++] = array[rpos++];
  }

  while(lpos <= leftend)
    tmp[tmppos++] = array[lpos++];
  while(rpos <= rend)
    tmp[tmppos++] = array[rpos++];

  for(i = 0;i < num;i++,rend--)
    array[rend] = tmp[rend];
}

歸并排序：將一個無序數(shù)組合并成一個有序數(shù)組

有兩種實現(xiàn)方法：自底向上和自頂向下

1、自底向上的方法（自底向上的歸并排序算法雖然效率較高，但可讀性較差。）

（1）自底向上的基本思想：

自底向上的基本思想是：第1趟歸并排序時，將待排序的文件R[1..n]看作是n個長度為1的有序子文件，將這些子文件兩兩歸并，若n為偶數(shù)，則得到n/2個長度為2的有序子文件；若n為奇數(shù)，則最后一個子文件輪空(不參與歸并)。故本趟歸并完成后，前l(fā)ogn個有序子文件長度為2，但最后一個子文件長度仍為1；第2趟歸并則是將第1趟歸并所得到的logn個有序的子文件兩兩歸并，如此反復，直到最后得到一個長度為n的有序文件為止。
上述的每次歸并操作，均是將兩個有序的子文件合并成一個有序的子文件，故稱其為"二路歸并排序"。類似地有k(k>2)路歸并排序。

（2）一趟歸并算法
分析：
在某趟歸并中，設各子文件長度為length(最后一個子文件的長度可能小于length)，則歸并前R[1..n]中共有個有序的子文件：R[1..length]，R[length+1..2length]，…

注意：

調(diào)用歸并操作將相鄰的一對子文件進行歸并時，必須對子文件的個數(shù)可能是奇數(shù)、以及最后一個子文件的長度小于length這兩種特殊情況進行特殊處理：

① 若子文件個數(shù)為奇數(shù)，則最后一個子文件無須和其它子文件歸并(即本趟輪空)；
② 若子文件個數(shù)為偶數(shù)，則要注意最后一對子文件中后一子文件的區(qū)間上界是n。

具體算法如下：

/*自底向上，這里就不寫真正的代碼了，從網(wǎng)上copy了*/
void MergePass(SeqList R，int length)
{ //對R[1..n]做一趟歸并排序
  int i;
  for(i=1;i+2*length-1<=n;i=i+2*length)
    Merge(R,i,i+length-1,i+2*length-1);
  //歸并長度為length的兩個相鄰子文件
  if(i+length-1<n) //尚有兩個子文件，其中后一個長度小于length
    Merge(R,i,i+length-1，n)； //歸并最后兩個子文件
//注意：若i≤n且i+length-1≥n時，則剩余一個子文件輪空，無須歸并
} //MergePass

void MergeSort(SeqList R)
{//采用自底向上的方法，對R[1..n]進行二路歸并排序
  int length;
  for(1ength=1;length<n;length*=2) //做 趟歸并
    MergePass(R，length); //有序段長度≥n時終止
}

2、自頂向下的方法

采用分治法進行自頂向下的算法設計，形式更為簡潔。

（1）分治法的三個步驟

設歸并排序的當前區(qū)間是R[low..high]，分治法的三個步驟是：

①分解：將當前區(qū)間一分為二，即求分裂點：mid = (low+high)/2;
②求解：遞歸地對兩個子區(qū)間R[low..mid]和R[mid+1..high]進行歸并排序；
③組合：將已排序的兩個子區(qū)間R[low..mid]和R[mid+1..high]歸并為一個有序的區(qū)間R[low..high]。

遞歸的終結(jié)條件：子區(qū)間長度為1（一個記錄自然有序）。

具體算法：

void MSort(int arr[],int low,int high)
{
  if(low < high){
    int mid = (low+high)/2;
    MSort(arr,low,mid);   //左半?yún)^(qū)排序
    MSort(arr,mid+1,high); //右半?yún)^(qū)排序
    Merge(arr,low,mid,high);//左右半?yún)^(qū)合并
  }
}

三：分析

1、穩(wěn)定性
歸并排序是一種穩(wěn)定的排序。

2、存儲結(jié)構(gòu)要求
可用順序存儲結(jié)構(gòu)。也易于在鏈表上實現(xiàn)。

3、時間復雜度
對長度為n的文件，需進行l(wèi)gn趟二路歸并，每趟歸并的時間為O(n)，故其時間復雜度無論是在最好情況下還是在最壞情況下均是O(nlgn)。

4、空間復雜度
需要一個輔助向量來暫存兩有序子文件歸并的結(jié)果，故其輔助空間復雜度為O(n)，顯然它不是就地排序。

注意：
若用單鏈表做存儲結(jié)構(gòu)，很容易給出就地的歸并排序。

您可能感興趣的文章: