归并排序(Merge-Sort)的C语言实现

归并排序是分治法(Divide-and-Conquer)的典型应用：

Divide the problem into a number of subproblems.

Conquer the subproblems by solving them recursively. if the subproblem sizes are small enough, just sovle the subproblems in a straightforward manner.

Combine the solutions to the subproblems into the solution for the original problem.

对于归并排序，需要考量的是：

递：将待排序数组划分为左边和右边，并对于左边和右边进行递归地排序。直到左边和右边只剩下一个元素——直接求解。

归：递归合并结果得到最终解。

代码：

#include "stdafx.h"
#define MAX 99999;
#define SIZE 7

void PrintNewLine();
void PrintArray(int arr[]);
void MergeSort(int arr[], int p, int r);
void Merge(int arr[], int p, int q, int r);

int _tmain(int argc, _TCHAR* argv[])
{
int original[] = {6,4,3,1,7,5,2};
PrintArray(original);
PrintNewLine();

MergeSort(original,0,SIZE - 1);
PrintArray(original);
PrintNewLine();

char wait = getchar();
return 0;
}

void MergeSort(int arr[], int p, int r)
{
if( r > p )
{
//divide&conqurer by recursion
int q = (p + r) / 2;
MergeSort(arr, p, q);
MergeSort(arr, q+1, r);

//combine
Merge(arr, p, q, r);

printf("Merge(%d,%d,%d) => ",p,q,r);
PrintArray(arr);
PrintNewLine();

}
}
void Merge(int arr[], int p, int q, int r)
{
//calc left side and right side
int nLeft = (q - p) + 1;
int nRight = r - q;

int* leftArr = new int[nLeft];
int* rightArr = new int[nRight];

//copy element to left&right side
for(int i = 0; i < nLeft; i++)
{
leftArr[i]=arr[p+i];
}
for(int j=0; j<nRight; j++)
{
rightArr[j]=arr[(q+j) + 1];
}

//sentinel
leftArr[nLeft] = MAX;
rightArr[nRight] = MAX;

//pick the small card in original array
int i = 0, j = 0;
for(int k = p; k <= r; k++)
{
if(leftArr[i] < rightArr[j])     //sentinel takes effect
{
arr[k] = leftArr[i];
i++;
}
else
{
arr[k] = rightArr[j];
j++;
}
}
}

void PrintArray(int arr[])
{
for(int i = 0; i < SIZE; i++)
printf("%d ",arr[i]);
}
void PrintNewLine()
{
printf("\n");
}

 

输出：

6 4 3 1 7 5 2
Merge(0,0,1) => 4 6 3 1 7 5 2
Merge(2,2,3) => 4 6 1 3 7 5 2
Merge(0,1,3) => 1 3 4 6 7 5 2
Merge(4,4,5) => 1 3 4 6 5 7 2
Merge(4,5,6) => 1 3 4 6 2 5 7
Merge(0,3,6) => 1 2 3 4 5 6 7
1 2 3 4 5 6 7

 

递归排序的算法复杂度为：O(nlgn)。