归并排序

问题很简单，就是给一串无序数字按某种顺序排序。

这里介绍归并排序法

该方法用了分治的思想
时间复杂度为O(nlogn) 这是该算法中最好、最坏和平均的时间性能。

空间复杂度为 O(n)

比较操作的次数介于(nlogn) / 2和nlogn - n + 1。

赋值操作的次数是(2nlogn)。归并算法的空间复杂度为：0 (n)

归并排序比较占用内存，但却是一种效率高且稳定的算法。

以  9 7 5 4 这个序列为例   如果要把它排成 从小到大 的顺序并输出。

1. 假设我们已经知道两个有序数列  7 9 和 4 5 （这四个元素下标肯定是连在一起的），我们就将这两个数列进行合并操作

            1. 比较 7 和 4 将小的那个（4）拿出，放到一个新的数组（这里假定为b[ ]）中（新数组中4的位置为原数列中7的下标）

            2. 然后比较 7 和 5，执行同样的操作

            3. 这时第二个数列已经没有元素了，我们就把 7 和 9顺次输入到b[ ]中

            4. 用b[ ]去更新原数列（这一步很重要，b[ ]其实起了个临时储存的作用，每一次合并操作，b[ ]都是新的）

2. 那么我们的有序数列便是通过分治与合并得到的。当我们分治，直到分到一个序列只有一个元素时，我们认为这一个元素是有序的，然后我们可以将两个只有一个元素的序列

进行合并（合并操作就是1中的操作），这样，合并后就会得到n个有序的数列（每个数列有两个元素）

3. 再将这n个有序数列两两进行合并操作。

4. 。。。

5. 剩下两个序列，将它们合并，成为最终一个有序数列，大功告成。

按照上面的思路的代码

#include <cstdio>
using namespace std;
const int MAX = 1000005;
int a[MAX], b[MAX];

void Merge(int *a, int left, int mid, int right)
{
    int i = left, j = mid + 1, k = left;
    while(i <= mid && j <= right){
        if(a[i] <= a[j]){
            b[k++] = a[i++];
        }
        else{
            b[k++] = a[j++];
        }
    }
    while(i <= mid){
        b[k++] = a[i++];
    }
    while(j <= right){
        b[k++] = a[j++];
    }
    for(int i = left; i <= right; i++){
        a[i] = b[i];
    }
}

void Mergesort(int *a, int left, int right)
{
    if(left < right){
        int mid = (left + right) / 2;
        Mergesort(a, left, mid);
        Mergesort(a, mid + 1, right);
        Merge(a, left, mid, right);
    }
}

int main()
{
    int T, n;
    scanf("%d", &T);
    while(T--){
        scanf("%d", &n);
        for(int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        Mergesort(a, 1, n);
        for(int i = 1; i <= n; i++)
            printf("%d ", a[i]);
        printf("\n");
    }
    return 0;
}

上面还说了这种排序是稳定的，那么这个又怎么解释呢？

再来个例子， 比如说  9 8 8* 7 5 3 1 0 从小到大排序

按照上面的过程 ， 最后排序结果应该是 0 1 3 5 7 8 8* 9， 因为 8 和 8* 的相对位置并不会改变， 所以这个排序可以说是很稳定的。