归并排序

先说一下，这个归并排序（版本一）是我自己的一些想法。简单地浏览了一下书本（《算法：C语言实现》（第三版）），实现方法并不一致。

但是这个算法我测试了一下，还行。

归并排序：分治法的思路。把一个待排序的数组（arr）分成两半（arrA和arrB）进行归并排序。在归并排序的过程中，arrA再分成两半……这个过程直到子数组无可再分。然后就回溯（应该是这么用这个名词），分别这些一对一对的细小的子数组进行插入排序……当这个过程回溯到arr的时候，由于arrA和arrB都已经是有序的子数组了，对arr的插入排序的工作量就相当小了。

版本一：

void
InsertSort(int arr[], int left, int right)
{
    for (int i = left+1; i <= right; i++) {
        int tmp = arr[i];
        for (int j = i-1; j >= 0 && arr[j] > tmp; j--) {
            arr[j+1] = arr[j];
            arr[j] = tmp;
        }
    }
}

void
MergeSort(int arr[], int left, int right)
{
    if (left == right) {
        return;
    }
    
    int middle = (left + right) / 2;
    
    MergeSort(arr, left, middle);
    MergeSort(arr, middle+1, right);
    
    InsertSort(arr, left, right);
}

 版本二：读了Mark Allen Weiss的《数据结构与算法分析——C语言描述》（第二版），知道自己写的归并排序有分治的思想，但是在时间复杂度上其实还是维持插入排序的程度，是O(n^2)，达不到O(nlogn)的程度。根据书本的知识，有了版本二的算法。

// 作合并操作 
void
Merge(int arr[], int tmpArr[], int leftPos, int rightPos, int rightEnd)
{
    int leftEnd = rightPos - 1;
    int len = rightEnd - leftPos + 1;
    int tmpPos = leftPos;
    
    while (leftPos <= leftEnd && rightPos <= rightEnd) {
        if (arr[leftPos] < arr[rightPos]) {
            tmpArr[tmpPos++] = arr[leftPos++];
        } else {
            tmpArr[tmpPos++] = arr[rightPos++];
        }
    }
    
    while (leftPos <= leftEnd) {
        tmpArr[tmpPos++] = arr[leftPos++];
    }
    while (rightPos <= rightEnd) {
        tmpArr[tmpPos++] = arr[rightPos++];
    }
    
    for (int i = 0; i < len; i++, rightEnd--) {
        arr[rightEnd] = tmpArr[rightEnd];
    }
}


// 归并排序 
void
MergeSort(int arr[], int tmpArr[], int left, int right)
{
    if (left < right) {
        
        int middle = (left + right) / 2;
        
        MergeSort(arr, tmpArr, left, middle);
        MergeSort(arr, tmpArr, middle+1, right);
        
        Merge(arr, tmpArr, left, middle+1, right);
    }
}