归并排序

【0】README

0.1） 本文总结于 数据结构与算法分析，但源代码均为原创；旨在理清归并排序的具体步骤；
0.2）归并排序： 它对于分析分治问题，很有代表性；

【1】归并排序相关

1.1）归并排序以 O（NlogN）最坏情形运行时间运行， 而所使用的比较次数几乎是最优的， 它是递归算法的一个很好地示例；
1.2）归并排序算法步骤：这个算法中基本的操作是合并两个已排序的表。因为 这两个表是已排序的，所以若将输出放到第3个表中时， 则该算法可以通过对输入数据一趟排序来完成。基本的合并算法是提取两个输入数组A 和 B， 一个输出数组C，以及 计数器 Aptr， Bptr， Cptr， 他们初始置于对应数组的开始端。A[Aptr] 和 B[Bptr] 中的较小者被copy 到 C中的下一个位置， 相关的计数器向前推进一步。当两个输入表有一个用完的时候， 则将另一个表中剩余部分copy 到 C中；
1.3）合并（merge）例程的荔枝：合并两个已排序的表的时间显然是线性的， 因为最多进行了N-1次比较， 其中N是元素个数， 为了看清这一点， 注意每次比较都是把一个元素加到C中， 但最后的比较除外， 它至少添加了两个元素（下图荔枝）；

【2】看个荔枝：

2.1）具体步骤：欲将8个元素数组 24， 13， 26， 1， 2， 27， 38， 15 排序，我们递归地将前4个数据和 后4个数据分序， 得到1， 13， 24， 26， 2， 15， 27， 38。然后将这两部分合并。最后得到 1， 2， 13， 15， 24， 26， 27， 38。该算法是经典的分治策略， 它将问题分成一些小的问题然后递归求解， 而治的阶段将分的阶段解得的各个答案修补到一起。分治是递归非常有力的用法；
2.2）看个荔枝：

2.3）解决空间复杂度问题： 如果对 merge的每个递归调用均局部声明一个临时数组， 那么在任意时刻就可能有 logN个临时数组处在活动期， 这对于小内存的机器则是致命的。另一个方面， 如果merge例程动态分配并释放最小量临时内存， 那么由malloc 占用的时间会很久。 严密测试指出， 由于merge 位于Msort的最后一行， 因此在任意时刻只需要一个临时数组活动，而且可以使用该临时数组的任意部分。我们将使用与输入数组 A 相同的部分， 这就达到本节末尾描述的改进；

【3】 归并排序的分析（对于分析分治问题，很有代表性）

3.1）归并排序是用于分析递归例程方法的经典实例： 我们必须给出运行时间写出一个递归关系；
3.2）假设N是2的幂， 从而我们总可以将它分裂成均为偶数大家两部分；
3.3）对于N=1， 归并排序所用时间为常数， 我们将记为1； 否则， 对N 个数归并排序的用时等于完成两个大小为 N/2 的递归排序所用的时间再加上合并的时间， 它是线性的；
3.4）推导出归并排序的时间复杂度：

【4】源代码+打印结果

4.1）download source code ：https://github.com/pacosonTang/dataStructure-algorithmAnalysis/blob/master/chapter7/p176_mergeSort.c
4.2）source code at a glance :

#include <stdio.h>
#include <malloc.h>

#define ElementType int
#define Error(str) printf("\n error: %s \n",str)

void printArray(ElementType data[], int size);

void mergeArray(ElementType *data, ElementType *temp, int left, int center, int right)
{
    int start1;
    int start2;
    int end1;
    int end2;
    int index;

    start1 = left;
    end1 = center;
    start2 = center + 1;
    end2 = right;
    index = left;

    while(start1 <= end1 && start2 <= end2)
        if(data[start1] < data[start2])
            temp[index++] = data[start1++];
        else
            temp[index++] = data[start2++];
    while(start1 <= end1)
        temp[index++] = data[start1++];
    while(start2 <= end2)
        temp[index++] = data[start2++];

    for(index = left; index <= right ; index++)
        data[index] = temp[index];
}

void mergeSort(ElementType *data, ElementType *temp, int left, int right)
{
    int center;
    if(left < right)
    {
        center = (left + right) / 2;
        mergeSort(data, temp, left, center);
        mergeSort(data, temp, center + 1, right);
        mergeArray(data, temp, left, center, right);
    }
} 

int main()
{ 
    int size;
    ElementType data[] = {10, 100, 20, 90, 60, 50, 120, 140, 130, 5};
    ElementType *temp;

    size = 10;

    printf("\n\t=== test for building heap with {10, 100, 20, 90, 60, 50, 120, 140, 130, 5} ===\n");        
    printf("\n\t=== before executing merge sorting ===\n"); 
    printArray(data, size); 

    temp = malloc(size * sizeof(ElementType));
    if(!temp)
    {
        Error("out of space, from func main");        
        return -1;
    }

    mergeSort(data, temp, 0, size-1);   
    // void mergeSort(ElementType *data, ElementType *temp, int left, int right)
    printf("\n\t=== after executing merge sorting ===\n");      
    printArray(data, size); 

    return 0;
}

void printArray(ElementType data[], int size)
{
    int i;

    for(i = 0; i < size; i++)    
        printf("\n\t index[%d] = %d", i, data[i]);                   
    printf("\n");
} 

3.3）打印结果：