归并排序(merge sort)

M erge sort is based on the divide-and-conquer paradigm. Its worst-case running time has a lower order of growth
than insertion sort. Since we are dealing with subproblems, we state each subproblem as sorting a subarray A[p .. r].
Initially, p = 1 and r = n, but these values change as we recurse through subproblems.

To sort A[p .. r]:
1. Divide Step
If a given array A has zero or one element, simply return; it is already sorted. Otherwise, split A[p .. r]
into two subarrays A[p .. q] and A[q + 1 .. r], each containing about half of the elements of A[p .. r].
That is, q is the halfway point of A[p .. r].
2. Conquer Step
Conquer by recursively sorting the two subarrays A[p .. q] and A[q + 1 .. r].
3. Combine Step
Combine the elements back in A[p .. r] by merging the two sorted subarrays A[p .. q] and A[q + 1 .. r] into
a sorted sequence. To accomplish this step, we will define a procedure MERGE (A, p, q, r).
Note that the recursion bottoms out when the subarray has just one element, so that it is trivially sorted.

归并操作

归并操作(merge)，也叫归并算法，指的是将两个顺序序列合并成一个顺序序列的方法。

如　设有数列{6，202，100，301，38，8，1}

初始状态：6,202,100,301,38,8，1

第一次归并后：{6,202},{100,301},{8,38},{1}，比较次数：3；

第二次归并后：{6,100,202,301}，{1,8,38}，比较次数：4；

第三次归并后：{1,6,8,38,100,202,301},比较次数：4；

总的比较次数为：3+4+4=11,；

逆序数为14；

 

 /* C program for Merge Sort */
 #include<stdlib.h>
 #include<stdio.h>

 // Merges two subarrays of arr[].
 // First subarray is arr[l..m]
 // Second subarray is arr[m+1..r]
 void merge(int arr[], int l, int m, int r)
 {
     int i, j, k;
     ;
     int n2 = r - m;

     /* create temp arrays */
     int L[n1], R[n2];

     /* Copy data to temp arrays L[] and R[] */
     ; i < n1; i++)
         L[i] = arr[l + i];
     ; j < n2; j++)
         R[j] = arr[m + + j];

     /* Merge the temp arrays back into arr[l..r]*/
     i = ; // Initial index of first subarray
     j = ; // Initial index of second subarray
     k = l; // Initial index of merged subarray
     while (i < n1 && j < n2)
     {
         if (L[i] <= R[j])
         {
             arr[k] = L[i];
             i++;
         }
         else
         {
             arr[k] = R[j];
             j++;
         }
         k++;
     }

     /* Copy the remaining elements of L[], if there
     are any */
     while (i < n1)
     {
         arr[k] = L[i];
         i++;
         k++;
     }

     /* Copy the remaining elements of R[], if there
     are any */
     while (j < n2)
     {
         arr[k] = R[j];
         j++;
         k++;
     }
 }

 /* l is for left index and r is right index of the
 sub-array of arr to be sorted */
 void mergeSort(int arr[], int l, int r)
 {
     if (l < r)
     {
         // Same as (l+r)/2, but avoids overflow for
         // large l and h
         ;

         // Sort first and second halves
         mergeSort(arr, l, m);
         mergeSort(arr, m+, r);

         merge(arr, l, m, r);
     }
 }

 /* UTILITY FUNCTIONS */
 /* Function to print an array */
 void printArray(int A[], int size)
 {
     int i;
     ; i < size; i++)
         printf("%d ", A[i]);
     printf("\n");
 }

 /* Driver program to test above functions */
 int main()
 {
     , , , , , };
     ]);

     printf("Given array is \n");
     printArray(arr, arr_size);

     mergeSort(arr, , arr_size - );

     printf("\nSorted array is \n");
     printArray(arr, arr_size);
     ;
 }