【算法系列】归并排序算法

1. 归并排序算法

1.1     算法描述：

 

Merge-sort (A[1, n])

    1.   if  n = 1, done

    2.   Recursivelysort A[1, n/2] (call A₁) and A[n/2 + 1, n] (call A₂)

    3.   merge two sorted lists (merge method ) 

Merge-method (A₁[1, n], A₂[1,m], A[1, n+m])

 i ← 1

 j ← 1

 k ← 1

while i < n and j < m

do

if  A₁[i] < A₂[j]

         A[k] = A₁[i]

         i ← 1 + i

     else

         A[k] = A₂[j]

         j ← 1 + j

     k ← k + 1

 while  i < n

 do

     A[k] = A₁[i]

     i ← 1 + i

    k ← k + 1

while  j < m

do

     A[k] = A₂[j]

     j ← 1+ j

    k ← k + 1

 

1.1     算法执行过程

(图片来源于维基百科)

1.2     时间复杂度

最大花费时间：

 

采用渐近分析和大O符号得到：

    T(n)= O(nlogn)

分析  T(n)= 2T(n/2)+ θ(n) 如何计算？

方法1（主定理）：

        期望形式：T(n)=aT(n/b)+ f(n)

        所以得到a = 2， b = 2，log_ba = 1， f(n) = O(n)

        符合主定理情况2(此处k=0)，得到:

         T(n)= O(nlogn)

方法2（递归树分析法）：

递归树的最大花费时间可用以下式子表达：

  T(n)=aT(n/b)+c∙n ,c>0

 画成树的结构如下：

 时间复杂性:

T(n)  =  log⁡n∙ cn +θ(n)= O(nlogn)

                          

1.3     C语言实现

void merge_method (int array[], int start, intend)
{
       inti = start, j = 0, k = 0;
       intmid = (start + end) / 2;
       int*temp = (int *)malloc(sizeof(int) * (end - start + 1));
      
       j =mid + 1;
       while((i <= mid) && (j <= end)) {
              if(array[i] < array[j]) {
                     temp[k]= array[i];
                     i++;
              }else {
                     temp[k]= array[j];
                     j++;
              }
              k++;
       }
       while(i <= mid) {
              temp[k++]= array[i];
              i++;
       }
       while(j <= end) {
              temp[k++]= array[j];
              j++;
       }
       memcpy(&array[start],temp, sizeof(int) * (end - start + 1));
       free(temp);
}
void merge_sort (int array[], int start, intend)
{
    intmid;
      
       if(start >= end) return;
       mid= (start + end) / 2;
      
       merge_sort(array,start, mid);
       merge_sort(array,mid + 1, end);
       merge_method(array,start, end);
}